- Formatting changes from uncrustify git-svn-id: svn://svn.berlios.de/openocd/trunk@1366 b42882b7-edfa-0310-969c-e2dbd0fdcd60tags/v0.2.0
@@ -111,7 +111,7 @@ int str9xpec_register_commands(struct command_context_s *cmd_ctx) | |||
return ERROR_OK; | |||
} | |||
int str9xpec_set_instr(jtag_tap_t *tap, u32 new_instr, enum tap_state end_state) | |||
int str9xpec_set_instr(jtag_tap_t *tap, u32 new_instr, tap_state_t end_state) | |||
{ | |||
if( tap == NULL ){ | |||
return ERROR_TARGET_INVALID; | |||
@@ -32,23 +32,23 @@ | |||
#include "binarybuffer.h" | |||
const unsigned char bit_reverse_table256[] = | |||
const unsigned char bit_reverse_table256[] = | |||
{ | |||
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, | |||
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, | |||
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, | |||
0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, | |||
0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, | |||
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, | |||
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, | |||
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, | |||
0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, | |||
0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, | |||
0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, | |||
0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, | |||
0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, | |||
0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, | |||
0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, | |||
0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, | |||
0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, | |||
0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, | |||
0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, | |||
0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, | |||
0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, | |||
0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, | |||
0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, | |||
0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, | |||
0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF | |||
}; | |||
@@ -63,8 +63,8 @@ u8* buf_cpy(u8 *from, u8 *to, int size) | |||
for (i = 0; i < num_bytes; i++) | |||
to[i] = from[i]; | |||
/* mask out bits that don't belong to the buffer */ | |||
/* mask out bits that don't belong to the buffer */ | |||
if (size % 8) | |||
{ | |||
to[size / 8] &= (0xff >> (8 - (size % 8))); | |||
@@ -111,7 +111,7 @@ int buf_cmp_mask(u8 *buf1, u8 *buf2, u8 *mask, int size) | |||
/* mask out bits that don't really belong to the buffer if size isn't a multiple of 8 bits */ | |||
if ((size % 8) && (i == num_bytes -1 )) | |||
{ | |||
if ((buf1[i] & ((1 << (size % 8)) - 1) & mask[i]) != | |||
if ((buf1[i] & ((1 << (size % 8)) - 1) & mask[i]) != | |||
(buf2[i] & ((1 << (size % 8)) - 1) & mask[i])) | |||
return 1; | |||
} | |||
@@ -136,10 +136,10 @@ u8* buf_set_ones(u8 *buf, int count) | |||
buf[i] = 0xff; | |||
else | |||
buf[i] = (1 << count) - 1; | |||
count -= 8; | |||
} | |||
return buf; | |||
} | |||
@@ -147,7 +147,7 @@ u8* buf_set_buf(u8 *src, int src_start, u8 *dst, int dst_start, int len) | |||
{ | |||
int src_idx = src_start, dst_idx = dst_start; | |||
int i; | |||
for (i = 0; i < len; i++) | |||
{ | |||
if (((src[src_idx/8] >> (src_idx % 8)) & 1) == 1) | |||
@@ -164,9 +164,9 @@ u8* buf_set_buf(u8 *src, int src_start, u8 *dst, int dst_start, int len) | |||
u32 flip_u32(u32 value, unsigned int num) | |||
{ | |||
u32 c; | |||
c = (bit_reverse_table256[value & 0xff] << 24) | | |||
(bit_reverse_table256[(value >> 8) & 0xff] << 16) | | |||
c = (bit_reverse_table256[value & 0xff] << 24) | | |||
(bit_reverse_table256[(value >> 8) & 0xff] << 16) | | |||
(bit_reverse_table256[(value >> 16) & 0xff] << 8) | | |||
(bit_reverse_table256[(value >> 24) & 0xff]); | |||
@@ -179,21 +179,21 @@ u32 flip_u32(u32 value, unsigned int num) | |||
int ceil_f_to_u32(float x) | |||
{ | |||
u32 y; | |||
if (x < 0) /* return zero for negative numbers */ | |||
return 0; | |||
y = x; /* cut off fraction */ | |||
if ((x - y) > 0.0) /* if there was a fractional part, increase by one */ | |||
y++; | |||
return y; | |||
} | |||
char* buf_to_str(const u8 *buf, int buf_len, int radix) | |||
{ | |||
const char *DIGITS = "0123456789abcdef"; | |||
const char *DIGITS = "0123456789ABCDEF"; | |||
float factor; | |||
char *str; | |||
int str_len; | |||
@@ -202,7 +202,7 @@ char* buf_to_str(const u8 *buf, int buf_len, int radix) | |||
int j; /* base-256 digits */ | |||
int i; /* output digits (radix) */ | |||
if (radix == 16) | |||
{ | |||
factor = 2.0; /* log(256) / log(16) = 2.0 */ | |||
@@ -217,10 +217,10 @@ char* buf_to_str(const u8 *buf, int buf_len, int radix) | |||
} | |||
else | |||
return NULL; | |||
str_len = ceil_f_to_u32(CEIL(buf_len, 8) * factor); | |||
str = calloc(str_len + 1, 1); | |||
for (i = b256_len - 1; i >= 0; i--) | |||
{ | |||
tmp = buf[i]; | |||
@@ -237,7 +237,7 @@ char* buf_to_str(const u8 *buf, int buf_len, int radix) | |||
for (j = 0; j < str_len; j++) | |||
str[j] = DIGITS[(int)str[j]]; | |||
return str; | |||
} | |||
@@ -247,12 +247,12 @@ int str_to_buf(const char *str, int str_len, u8 *buf, int buf_len, int radix) | |||
u32 tmp; | |||
float factor; | |||
u8 *b256_buf; | |||
int b256_len; | |||
int b256_len; | |||
int j; /* base-256 digits */ | |||
int i; /* input digits (ASCII) */ | |||
if (radix == 0) | |||
if (radix == 0) | |||
{ | |||
/* identify radix, and skip radix-prefix (0, 0x or 0X) */ | |||
if ((str[0] == '0') && (str[1] && ((str[1] == 'x') || (str[1] == 'X')))) | |||
@@ -272,7 +272,7 @@ int str_to_buf(const char *str, int str_len, u8 *buf, int buf_len, int radix) | |||
radix = 10; | |||
} | |||
} | |||
if (radix == 16) | |||
factor = 0.5; /* log(16) / log(256) = 0.5 */ | |||
else if (radix == 10) | |||
@@ -286,14 +286,14 @@ int str_to_buf(const char *str, int str_len, u8 *buf, int buf_len, int radix) | |||
charbuf = malloc(str_len + 1); | |||
memcpy(charbuf, str, str_len); | |||
charbuf[str_len] = '\0'; | |||
/* number of digits in base-256 notation */ | |||
b256_len = ceil_f_to_u32(str_len * factor); | |||
b256_buf = calloc(b256_len, 1); | |||
/* go through zero terminated buffer */ | |||
for (i = 0; charbuf[i]; i++) | |||
{ | |||
{ | |||
tmp = charbuf[i]; | |||
if ((tmp >= '0') && (tmp <= '9')) | |||
tmp = (tmp - '0'); | |||
@@ -302,19 +302,19 @@ int str_to_buf(const char *str, int str_len, u8 *buf, int buf_len, int radix) | |||
else if ((tmp >= 'A') && (tmp <= 'F')) | |||
tmp = (tmp - 'A' + 10); | |||
else continue; /* skip characters other than [0-9,a-f,A-F] */ | |||
if (tmp >= radix) | |||
continue; /* skip digits invalid for the current radix */ | |||
continue; /* skip digits invalid for the current radix */ | |||
for (j = 0; j < b256_len; j++) | |||
{ | |||
tmp += (u32)b256_buf[j] * radix; | |||
b256_buf[j] = (u8)(tmp & 0xFF); | |||
tmp >>= 8; | |||
} | |||
} | |||
for (j = 0; j < CEIL(buf_len, 8); j++) | |||
{ | |||
if (j < b256_len) | |||
@@ -326,18 +326,18 @@ int str_to_buf(const char *str, int str_len, u8 *buf, int buf_len, int radix) | |||
/* mask out bits that don't belong to the buffer */ | |||
if (buf_len % 8) | |||
buf[(buf_len / 8)] &= 0xff >> (8 - (buf_len % 8)); | |||
free(b256_buf); | |||
free(charbuf); | |||
return i; | |||
} | |||
int buf_to_u32_handler(u8 *in_buf, void *priv, struct scan_field_s *field) | |||
{ | |||
u32 *dest = priv; | |||
*dest = buf_get_u32(in_buf, 0, 32); | |||
return ERROR_OK; | |||
} |
@@ -109,6 +109,7 @@ u8 amt_jtagaccel_tap_move[6][6][2] = | |||
{{0x1f, 0x00}, {0x0c, 0x00}, {0x07, 0x00}, {0x97, 0x00}, {0x08, 0x00}, {0x00, 0x00}}, /* IRPAUSE */ | |||
}; | |||
jtag_interface_t amt_jtagaccel_interface = | |||
{ | |||
.name = "amt_jtagaccel", | |||
@@ -157,8 +158,8 @@ int amt_jtagaccel_speed(int speed) | |||
void amt_jtagaccel_end_state(int state) | |||
{ | |||
if (tap_move_map[state] != -1) | |||
end_state = state; | |||
if (tap_is_state_stable(state)) | |||
tap_set_end_state(state); | |||
else | |||
{ | |||
LOG_ERROR("BUG: %i is not a valid end state", state); | |||
@@ -187,8 +188,11 @@ void amt_jtagaccel_state_move(void) | |||
u8 aw_scan_tms_5; | |||
u8 tms_scan[2]; | |||
tms_scan[0] = amt_jtagaccel_tap_move[tap_move_map[cur_state]][tap_move_map[end_state]][0]; | |||
tms_scan[1] = amt_jtagaccel_tap_move[tap_move_map[cur_state]][tap_move_map[end_state]][1]; | |||
tap_state_t cur_state = tap_get_state(); | |||
tap_state_t end_state = tap_get_end_state(); | |||
tms_scan[0] = amt_jtagaccel_tap_move[tap_move_ndx(cur_state)][tap_move_ndx(end_state)][0]; | |||
tms_scan[1] = amt_jtagaccel_tap_move[tap_move_ndx(cur_state)][tap_move_ndx(end_state)][1]; | |||
aw_scan_tms_5 = 0x40 | (tms_scan[0] & 0x1f); | |||
AMT_AW(aw_scan_tms_5); | |||
@@ -203,7 +207,7 @@ void amt_jtagaccel_state_move(void) | |||
amt_wait_scan_busy(); | |||
} | |||
cur_state = end_state; | |||
tap_set_state(end_state); | |||
} | |||
void amt_jtagaccel_runtest(int num_cycles) | |||
@@ -212,10 +216,10 @@ void amt_jtagaccel_runtest(int num_cycles) | |||
u8 aw_scan_tms_5; | |||
u8 aw_scan_tms_1to4; | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
/* only do a state_move when we're not already in IDLE */ | |||
if (cur_state != TAP_IDLE) | |||
if (tap_get_state() != TAP_IDLE) | |||
{ | |||
amt_jtagaccel_end_state(TAP_IDLE); | |||
amt_jtagaccel_state_move(); | |||
@@ -235,7 +239,7 @@ void amt_jtagaccel_runtest(int num_cycles) | |||
} | |||
amt_jtagaccel_end_state(saved_end_state); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
amt_jtagaccel_state_move(); | |||
} | |||
@@ -243,7 +247,7 @@ void amt_jtagaccel_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_s | |||
{ | |||
int bits_left = scan_size; | |||
int bit_count = 0; | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
u8 aw_tdi_option; | |||
u8 dw_tdi_scan; | |||
u8 dr_tdo; | |||
@@ -297,8 +301,8 @@ void amt_jtagaccel_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_s | |||
bits_left -= 8; | |||
} | |||
tms_scan[0] = amt_jtagaccel_tap_move[tap_move_map[cur_state]][tap_move_map[end_state]][0]; | |||
tms_scan[1] = amt_jtagaccel_tap_move[tap_move_map[cur_state]][tap_move_map[end_state]][1]; | |||
tms_scan[0] = amt_jtagaccel_tap_move[tap_move_ndx(tap_get_state())][tap_move_ndx(tap_get_end_state())][0]; | |||
tms_scan[1] = amt_jtagaccel_tap_move[tap_move_ndx(tap_get_state())][tap_move_ndx(tap_get_end_state())][1]; | |||
aw_tms_scan = 0x40 | (tms_scan[0] & 0x1f) | (buf_get_u32(buffer, bit_count, 1) << 5); | |||
AMT_AW(aw_tms_scan); | |||
if (jtag_speed > 3 || rtck_enabled) | |||
@@ -318,7 +322,7 @@ void amt_jtagaccel_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_s | |||
if (jtag_speed > 3 || rtck_enabled) | |||
amt_wait_scan_busy(); | |||
} | |||
cur_state = end_state; | |||
tap_set_state(tap_get_end_state()); | |||
} | |||
int amt_jtagaccel_execute_queue(void) | |||
@@ -351,7 +355,7 @@ int amt_jtagaccel_execute_queue(void) | |||
#endif | |||
if (cmd->cmd.reset->trst == 1) | |||
{ | |||
cur_state = TAP_RESET; | |||
tap_set_state(TAP_RESET); | |||
} | |||
amt_jtagaccel_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
break; | |||
@@ -404,26 +408,26 @@ int amt_jtagaccel_execute_queue(void) | |||
#if PARPORT_USE_GIVEIO == 1 | |||
int amt_jtagaccel_get_giveio_access(void) | |||
{ | |||
HANDLE h; | |||
OSVERSIONINFO version; | |||
HANDLE h; | |||
OSVERSIONINFO version; | |||
version.dwOSVersionInfoSize = sizeof version; | |||
if (!GetVersionEx( &version )) { | |||
version.dwOSVersionInfoSize = sizeof version; | |||
if (!GetVersionEx( &version )) { | |||
errno = EINVAL; | |||
return -1; | |||
} | |||
if (version.dwPlatformId != VER_PLATFORM_WIN32_NT) | |||
} | |||
if (version.dwPlatformId != VER_PLATFORM_WIN32_NT) | |||
return 0; | |||
h = CreateFile( "\\\\.\\giveio", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); | |||
if (h == INVALID_HANDLE_VALUE) { | |||
h = CreateFile( "\\\\.\\giveio", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); | |||
if (h == INVALID_HANDLE_VALUE) { | |||
errno = ENODEV; | |||
return -1; | |||
} | |||
} | |||
CloseHandle( h ); | |||
CloseHandle( h ); | |||
return 0; | |||
return 0; | |||
} | |||
#endif | |||
@@ -74,13 +74,12 @@ bitbang_interface_t *bitbang_interface; | |||
int bitbang_execute_queue(void); | |||
/* The bitbang driver leaves the TCK 0 when in idle */ | |||
void bitbang_end_state(enum tap_state state) | |||
void bitbang_end_state(tap_state_t state) | |||
{ | |||
if (tap_move_map[state] != -1) | |||
end_state = state; | |||
if (tap_is_state_stable(state)) | |||
tap_set_end_state(state); | |||
else | |||
{ | |||
LOG_ERROR("BUG: %i is not a valid end state", state); | |||
@@ -88,10 +87,10 @@ void bitbang_end_state(enum tap_state state) | |||
} | |||
} | |||
void bitbang_state_move(void) { | |||
void bitbang_state_move(void) | |||
{ | |||
int i=0, tms=0; | |||
u8 tms_scan = TAP_MOVE(cur_state, end_state); | |||
u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); | |||
for (i = 0; i < 7; i++) | |||
{ | |||
@@ -101,7 +100,7 @@ void bitbang_state_move(void) { | |||
} | |||
bitbang_interface->write(CLOCK_IDLE(), tms, 0); | |||
cur_state = end_state; | |||
tap_set_state(tap_get_end_state()); | |||
} | |||
void bitbang_path_move(pathmove_command_t *cmd) | |||
@@ -113,41 +112,41 @@ void bitbang_path_move(pathmove_command_t *cmd) | |||
state_count = 0; | |||
while (num_states) | |||
{ | |||
if (tap_transitions[cur_state].low == cmd->path[state_count]) | |||
if (tap_state_transition(tap_get_state(), FALSE) == cmd->path[state_count]) | |||
{ | |||
tms = 0; | |||
} | |||
else if (tap_transitions[cur_state].high == cmd->path[state_count]) | |||
else if (tap_state_transition(tap_get_state(), TRUE) == cmd->path[state_count]) | |||
{ | |||
tms = 1; | |||
} | |||
else | |||
{ | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(cmd->path[state_count])); | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count])); | |||
exit(-1); | |||
} | |||
bitbang_interface->write(0, tms, 0); | |||
bitbang_interface->write(1, tms, 0); | |||
cur_state = cmd->path[state_count]; | |||
tap_set_state(cmd->path[state_count]); | |||
state_count++; | |||
num_states--; | |||
} | |||
bitbang_interface->write(CLOCK_IDLE(), tms, 0); | |||
end_state = cur_state; | |||
tap_set_end_state(tap_get_state()); | |||
} | |||
void bitbang_runtest(int num_cycles) | |||
{ | |||
int i; | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
/* only do a state_move when we're not already in IDLE */ | |||
if (cur_state != TAP_IDLE) | |||
if (tap_get_state() != TAP_IDLE) | |||
{ | |||
bitbang_end_state(TAP_IDLE); | |||
bitbang_state_move(); | |||
@@ -163,14 +162,14 @@ void bitbang_runtest(int num_cycles) | |||
/* finish in end_state */ | |||
bitbang_end_state(saved_end_state); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
bitbang_state_move(); | |||
} | |||
static void bitbang_stableclocks(int num_cycles) | |||
{ | |||
int tms = (cur_state == TAP_RESET ? 1 : 0); | |||
int tms = (tap_get_state() == TAP_RESET ? 1 : 0); | |||
int i; | |||
/* send num_cycles clocks onto the cable */ | |||
@@ -185,10 +184,10 @@ static void bitbang_stableclocks(int num_cycles) | |||
void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) | |||
{ | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
int bit_cnt; | |||
if (!((!ir_scan && (cur_state == TAP_DRSHIFT)) || (ir_scan && (cur_state == TAP_IRSHIFT)))) | |||
if (!((!ir_scan && (tap_get_state() == TAP_DRSHIFT)) || (ir_scan && (tap_get_state() == TAP_IRSHIFT)))) | |||
{ | |||
if (ir_scan) | |||
bitbang_end_state(TAP_IRSHIFT); | |||
@@ -241,11 +240,11 @@ void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) | |||
bitbang_interface->write(CLOCK_IDLE(), 0, 0); | |||
if (ir_scan) | |||
cur_state = TAP_IRPAUSE; | |||
tap_set_state(TAP_IRPAUSE); | |||
else | |||
cur_state = TAP_DRPAUSE; | |||
tap_set_state(TAP_DRPAUSE); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
bitbang_state_move(); | |||
} | |||
@@ -277,7 +276,7 @@ int bitbang_execute_queue(void) | |||
{ | |||
case JTAG_END_STATE: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("end_state: %s", jtag_state_name(cmd->cmd.end_state->end_state) ); | |||
LOG_DEBUG("end_state: %s", tap_state_name(cmd->cmd.end_state->end_state) ); | |||
#endif | |||
if (cmd->cmd.end_state->end_state != -1) | |||
bitbang_end_state(cmd->cmd.end_state->end_state); | |||
@@ -288,13 +287,13 @@ int bitbang_execute_queue(void) | |||
#endif | |||
if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST))) | |||
{ | |||
cur_state = TAP_RESET; | |||
tap_set_state(TAP_RESET); | |||
} | |||
bitbang_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
break; | |||
case JTAG_RUNTEST: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, jtag_state_name(cmd->cmd.runtest->end_state) ); | |||
LOG_DEBUG("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(cmd->cmd.runtest->end_state) ); | |||
#endif | |||
if (cmd->cmd.runtest->end_state != -1) | |||
bitbang_end_state(cmd->cmd.runtest->end_state); | |||
@@ -310,7 +309,7 @@ int bitbang_execute_queue(void) | |||
case JTAG_STATEMOVE: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("statemove end in %s", jtag_state_name(cmd->cmd.statemove->end_state)); | |||
LOG_DEBUG("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state)); | |||
#endif | |||
if (cmd->cmd.statemove->end_state != -1) | |||
bitbang_end_state(cmd->cmd.statemove->end_state); | |||
@@ -319,13 +318,13 @@ int bitbang_execute_queue(void) | |||
case JTAG_PATHMOVE: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states, | |||
jtag_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1])); | |||
tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1])); | |||
#endif | |||
bitbang_path_move(cmd->cmd.pathmove); | |||
break; | |||
case JTAG_SCAN: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("%s scan end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", jtag_state_name(cmd->cmd.scan->end_state) ); | |||
LOG_DEBUG("%s scan end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", tap_state_name(cmd->cmd.scan->end_state) ); | |||
#endif | |||
if (cmd->cmd.scan->end_state != -1) | |||
bitbang_end_state(cmd->cmd.scan->end_state); | |||
@@ -1,22 +1,22 @@ | |||
/*************************************************************************** | |||
* Copyright (C) 2007 by Pavel Chromy * | |||
* chromy@asix.cz * | |||
* * | |||
* This program is free software; you can redistribute it and/or modify * | |||
* it under the terms of the GNU General Public License as published by * | |||
* the Free Software Foundation; either version 2 of the License, or * | |||
* (at your option) any later version. * | |||
* * | |||
* This program is distributed in the hope that it will be useful, * | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of * | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * | |||
* 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. * | |||
***************************************************************************/ | |||
* Copyright (C) 2007 by Pavel Chromy * | |||
* chromy@asix.cz * | |||
* * | |||
* This program is free software; you can redistribute it and/or modify * | |||
* it under the terms of the GNU General Public License as published by * | |||
* the Free Software Foundation; either version 2 of the License, or * | |||
* (at your option) any later version. * | |||
* * | |||
* This program is distributed in the hope that it will be useful, * | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of * | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * | |||
* 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. * | |||
***************************************************************************/ | |||
#ifdef HAVE_CONFIG_H | |||
#include "config.h" | |||
#endif | |||
@@ -34,12 +34,12 @@ | |||
#include <stdlib.h> | |||
#include <unistd.h> | |||
bitq_interface_t *bitq_interface; /* low level bit queue interface */ | |||
bitq_interface_t* bitq_interface; /* low level bit queue interface */ | |||
bitq_state_t bitq_in_state; /* state of input queue */ | |||
bitq_state_t bitq_in_state; /* state of input queue */ | |||
u8 *bitq_in_buffer; /* buffer dynamically reallocated as needed */ | |||
unsigned long bitq_in_bufsize=32; /* min. buffer size */ | |||
u8* bitq_in_buffer; /* buffer dynamically reallocated as needed */ | |||
unsigned long bitq_in_bufsize = 32; /* min. buffer size */ | |||
/* | |||
* input queue processing does not use jtag_read_buffer() to avoid unnecessary overhead | |||
@@ -49,284 +49,338 @@ unsigned long bitq_in_bufsize=32; /* min. buffer size */ | |||
void bitq_in_proc(void) | |||
{ | |||
/* static information preserved between calls to increase performance */ | |||
static u8 *in_buff; /* pointer to buffer for scanned data */ | |||
static int in_idx; /* index of byte being scanned */ | |||
static u8 in_mask; /* mask of next bit to be scanned */ | |||
static u8* in_buff; /* pointer to buffer for scanned data */ | |||
static int in_idx; /* index of byte being scanned */ | |||
static u8 in_mask; /* mask of next bit to be scanned */ | |||
scan_field_t *field; | |||
int tdo; | |||
scan_field_t* field; | |||
int tdo; | |||
/* loop through the queue */ | |||
while (bitq_in_state.cmd) { | |||
while (bitq_in_state.cmd) | |||
{ | |||
/* only JTAG_SCAN command may return data */ | |||
if (bitq_in_state.cmd->type==JTAG_SCAN) { | |||
if (bitq_in_state.cmd->type==JTAG_SCAN) | |||
{ | |||
/* loop through the fields */ | |||
while (bitq_in_state.field_idx<bitq_in_state.cmd->cmd.scan->num_fields) { | |||
field=&bitq_in_state.cmd->cmd.scan->fields[bitq_in_state.field_idx]; | |||
if ( field->in_value || field->in_handler) { | |||
if (bitq_in_state.bit_pos==0) { | |||
while (bitq_in_state.field_idx<bitq_in_state.cmd->cmd.scan->num_fields) | |||
{ | |||
field = &bitq_in_state.cmd->cmd.scan->fields[bitq_in_state.field_idx]; | |||
if (field->in_value || field->in_handler) | |||
{ | |||
if (bitq_in_state.bit_pos==0) | |||
{ | |||
/* initialize field scanning */ | |||
in_mask=0x01; | |||
in_idx=0; | |||
if (field->in_value) in_buff=field->in_value; | |||
else { | |||
in_mask = 0x01; | |||
in_idx = 0; | |||
if (field->in_value) | |||
in_buff = field->in_value; | |||
else | |||
{ | |||
/* buffer reallocation needed? */ | |||
if (field->num_bits>bitq_in_bufsize*8) { | |||
if (field->num_bits>bitq_in_bufsize * 8) | |||
{ | |||
/* buffer previously allocated? */ | |||
if (bitq_in_buffer!=NULL) { | |||
if (bitq_in_buffer!=NULL) | |||
{ | |||
/* free it */ | |||
free(bitq_in_buffer); | |||
bitq_in_buffer=NULL; | |||
bitq_in_buffer = NULL; | |||
} | |||
/* double the buffer size until it fits */ | |||
while (field->num_bits>bitq_in_bufsize*8) bitq_in_bufsize*=2; | |||
while (field->num_bits>bitq_in_bufsize * 8) | |||
bitq_in_bufsize *= 2; | |||
} | |||
/* if necessary, allocate buffer and check for malloc error */ | |||
if (bitq_in_buffer==NULL && (bitq_in_buffer=malloc(bitq_in_bufsize))==NULL) { | |||
if (bitq_in_buffer==NULL && ( bitq_in_buffer = malloc(bitq_in_bufsize) )==NULL) | |||
{ | |||
LOG_ERROR("malloc error"); | |||
exit(-1); | |||
} | |||
in_buff=(void *)bitq_in_buffer; | |||
in_buff = (void*) bitq_in_buffer; | |||
} | |||
} | |||
/* field scanning */ | |||
while (bitq_in_state.bit_pos<field->num_bits) { | |||
if ((tdo=bitq_interface->in())<0) { | |||
while (bitq_in_state.bit_pos<field->num_bits) | |||
{ | |||
if ( ( tdo = bitq_interface->in() )<0 ) | |||
{ | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("bitq in EOF"); | |||
#endif | |||
return; | |||
} | |||
if (in_mask==0x01) in_buff[in_idx]=0; | |||
if (tdo) in_buff[in_idx]|=in_mask; | |||
if (in_mask==0x80) { | |||
in_mask=0x01; | |||
if (in_mask==0x01) | |||
in_buff[in_idx] = 0; | |||
if (tdo) | |||
in_buff[in_idx] |= in_mask; | |||
if (in_mask==0x80) | |||
{ | |||
in_mask = 0x01; | |||
in_idx++; | |||
} | |||
else in_mask<<=1; | |||
else | |||
in_mask <<= 1; | |||
bitq_in_state.bit_pos++; | |||
} | |||
if (field->in_handler && bitq_in_state.status==ERROR_OK) { | |||
bitq_in_state.status=(*field->in_handler)(in_buff, field->in_handler_priv, field); | |||
if (field->in_handler && bitq_in_state.status==ERROR_OK) | |||
{ | |||
bitq_in_state.status = (*field->in_handler)(in_buff, field->in_handler_priv, field); | |||
} | |||
} | |||
bitq_in_state.field_idx++; /* advance to next field */ | |||
bitq_in_state.bit_pos=0; /* start next field from the first bit */ | |||
bitq_in_state.field_idx++; /* advance to next field */ | |||
bitq_in_state.bit_pos = 0; /* start next field from the first bit */ | |||
} | |||
} | |||
bitq_in_state.cmd=bitq_in_state.cmd->next; /* advance to next command */ | |||
bitq_in_state.field_idx=0; /* preselect first field */ | |||
bitq_in_state.cmd = bitq_in_state.cmd->next; /* advance to next command */ | |||
bitq_in_state.field_idx = 0; /* preselect first field */ | |||
} | |||
} | |||
void bitq_io(int tms, int tdi, int tdo_req) | |||
{ | |||
bitq_interface->out(tms, tdi, tdo_req); | |||
/* check and process the input queue */ | |||
if (bitq_interface->in_rdy()) bitq_in_proc(); | |||
if ( bitq_interface->in_rdy() ) | |||
bitq_in_proc(); | |||
} | |||
void bitq_end_state(enum tap_state state) | |||
void bitq_end_state(tap_state_t state) | |||
{ | |||
if (state==-1) return; | |||
if (tap_move_map[state]==-1) { | |||
if (state==-1) | |||
return; | |||
if (!tap_is_state_stable(state)) | |||
{ | |||
LOG_ERROR("BUG: %i is not a valid end state", state); | |||
exit(-1); | |||
} | |||
end_state = state; | |||
tap_set_end_state(state); | |||
} | |||
void bitq_state_move(enum tap_state new_state) | |||
void bitq_state_move(tap_state_t new_state) | |||
{ | |||
int i=0; | |||
u8 tms_scan; | |||
int i = 0; | |||
u8 tms_scan; | |||
if (tap_move_map[cur_state]==-1 || tap_move_map[new_state]==-1) { | |||
if (!tap_is_state_stable(tap_get_state()) || !tap_is_state_stable(new_state)) | |||
{ | |||
LOG_ERROR("TAP move from or to unstable state"); | |||
exit(-1); | |||
} | |||
tms_scan=TAP_MOVE(cur_state, new_state); | |||
tms_scan = tap_get_tms_path(tap_get_state(), new_state); | |||
for (i=0; i<7; i++) { | |||
bitq_io(tms_scan&1, 0, 0); | |||
tms_scan>>=1; | |||
for (i = 0; i<7; i++) | |||
{ | |||
bitq_io(tms_scan & 1, 0, 0); | |||
tms_scan >>= 1; | |||
} | |||
cur_state = new_state; | |||
tap_set_state(new_state); | |||
} | |||
void bitq_path_move(pathmove_command_t *cmd) | |||
void bitq_path_move(pathmove_command_t* cmd) | |||
{ | |||
int i; | |||
for (i=0; i<=cmd->num_states; i++) { | |||
if (tap_transitions[cur_state].low == cmd->path[i]) | |||
for (i = 0; i<=cmd->num_states; i++) | |||
{ | |||
if (tap_state_transition(tap_get_state(), FALSE) == cmd->path[i]) | |||
bitq_io(0, 0, 0); | |||
else if (tap_transitions[cur_state].high == cmd->path[i]) | |||
else if (tap_state_transition(tap_get_state(), TRUE) == cmd->path[i]) | |||
bitq_io(1, 0, 0); | |||
else { | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(cmd->path[i])); | |||
else | |||
{ | |||
LOG_ERROR( "BUG: %s -> %s isn't a valid TAP transition", tap_state_name( | |||
tap_get_state() ), tap_state_name(cmd->path[i]) ); | |||
exit(-1); | |||
} | |||
cur_state = cmd->path[i]; | |||
tap_set_state(cmd->path[i]); | |||
} | |||
end_state = cur_state; | |||
tap_set_end_state( tap_get_state() ); | |||
} | |||
void bitq_runtest(int num_cycles) | |||
{ | |||
int i; | |||
/* only do a state_move when we're not already in IDLE */ | |||
if (cur_state != TAP_IDLE) bitq_state_move(TAP_IDLE); | |||
if (tap_get_state() != TAP_IDLE) | |||
bitq_state_move(TAP_IDLE); | |||
/* execute num_cycles */ | |||
for (i = 0; i < num_cycles; i++) | |||
bitq_io(0, 0, 0); | |||
/* finish in end_state */ | |||
if (cur_state != end_state) bitq_state_move(end_state); | |||
if ( tap_get_state() != tap_get_end_state() ) | |||
bitq_state_move( tap_get_end_state() ); | |||
} | |||
void bitq_scan_field(scan_field_t *field, int pause) | |||
void bitq_scan_field(scan_field_t* field, int pause) | |||
{ | |||
int bit_cnt; | |||
int tdo_req; | |||
u8 *out_ptr; | |||
u8 out_mask; | |||
u8* out_ptr; | |||
u8 out_mask; | |||
if ( field->in_value || field->in_handler) tdo_req=1; | |||
else tdo_req=0; | |||
if (field->in_value || field->in_handler) | |||
tdo_req = 1; | |||
else | |||
tdo_req = 0; | |||
if (field->out_value==NULL) { | |||
if (field->out_value==NULL) | |||
{ | |||
/* just send zeros and request data from TDO */ | |||
for (bit_cnt=field->num_bits; bit_cnt>1; bit_cnt--) | |||
for (bit_cnt = field->num_bits; bit_cnt>1; bit_cnt--) | |||
bitq_io(0, 0, tdo_req); | |||
bitq_io(pause, 0, tdo_req); | |||
} | |||
else { | |||
else | |||
{ | |||
/* send data, and optionally request TDO */ | |||
out_mask=0x01; | |||
out_ptr=field->out_value; | |||
for (bit_cnt=field->num_bits; bit_cnt>1; bit_cnt--) { | |||
bitq_io(0, ((*out_ptr)&out_mask)!=0, tdo_req); | |||
if (out_mask==0x80) { | |||
out_mask=0x01; | |||
out_mask = 0x01; | |||
out_ptr = field->out_value; | |||
for (bit_cnt = field->num_bits; bit_cnt>1; bit_cnt--) | |||
{ | |||
bitq_io(0, ( (*out_ptr) & out_mask )!=0, tdo_req); | |||
if (out_mask==0x80) | |||
{ | |||
out_mask = 0x01; | |||
out_ptr++; | |||
} | |||
else out_mask<<=1; | |||
else | |||
out_mask <<= 1; | |||
} | |||
bitq_io(pause, ((*out_ptr)&out_mask)!=0, tdo_req); | |||
bitq_io(pause, ( (*out_ptr) & out_mask )!=0, tdo_req); | |||
} | |||
if (pause) { | |||
bitq_io(0,0,0); | |||
if (cur_state==TAP_IRSHIFT) cur_state=TAP_IRPAUSE; | |||
else if (cur_state==TAP_DRSHIFT) cur_state=TAP_DRPAUSE; | |||
if (pause) | |||
{ | |||
bitq_io(0, 0, 0); | |||
if (tap_get_state()==TAP_IRSHIFT) | |||
tap_set_state(TAP_IRPAUSE); | |||
else if (tap_get_state()==TAP_DRSHIFT) | |||
tap_set_state(TAP_DRPAUSE); | |||
} | |||
} | |||
void bitq_scan(scan_command_t *cmd) | |||
void bitq_scan(scan_command_t* cmd) | |||
{ | |||
int i; | |||
if (cmd->ir_scan) bitq_state_move(TAP_IRSHIFT); | |||
else bitq_state_move(TAP_DRSHIFT); | |||
if (cmd->ir_scan) | |||
bitq_state_move(TAP_IRSHIFT); | |||
else | |||
bitq_state_move(TAP_DRSHIFT); | |||
for (i=0; i < cmd->num_fields-1; i++) | |||
for (i = 0; i < cmd->num_fields - 1; i++) | |||
bitq_scan_field(&cmd->fields[i], 0); | |||
bitq_scan_field(&cmd->fields[i], 1); | |||
} | |||
int bitq_execute_queue(void) | |||
{ | |||
jtag_command_t *cmd = jtag_command_queue; /* currently processed command */ | |||
jtag_command_t* cmd = jtag_command_queue; /* currently processed command */ | |||
bitq_in_state.cmd = jtag_command_queue; | |||
bitq_in_state.field_idx = 0; | |||
bitq_in_state.bit_pos = 0; | |||
bitq_in_state.status = ERROR_OK; | |||
while (cmd) { | |||
bitq_in_state.bit_pos = 0; | |||
bitq_in_state.status = ERROR_OK; | |||
switch (cmd->type) { | |||
case JTAG_END_STATE: | |||
while (cmd) | |||
{ | |||
switch (cmd->type) | |||
{ | |||
case JTAG_END_STATE: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state); | |||
LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state); | |||
#endif | |||
bitq_end_state(cmd->cmd.end_state->end_state); | |||
break; | |||
bitq_end_state(cmd->cmd.end_state->end_state); | |||
break; | |||
case JTAG_RESET: | |||
case JTAG_RESET: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
#endif | |||
if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST))) | |||
{ | |||
cur_state = TAP_RESET; | |||
} | |||
bitq_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
if (bitq_interface->in_rdy()) bitq_in_proc(); | |||
break; | |||
if ( (cmd->cmd.reset->trst == 1) || ( cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST) ) ) | |||
{ | |||
tap_set_state(TAP_RESET); | |||
} | |||
bitq_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
if ( bitq_interface->in_rdy() ) | |||
bitq_in_proc(); | |||
break; | |||
case JTAG_RUNTEST: | |||
case JTAG_RUNTEST: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); | |||
LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); | |||
#endif | |||
bitq_end_state(cmd->cmd.runtest->end_state); | |||
bitq_runtest(cmd->cmd.runtest->num_cycles); | |||
break; | |||
bitq_end_state(cmd->cmd.runtest->end_state); | |||
bitq_runtest(cmd->cmd.runtest->num_cycles); | |||
break; | |||
case JTAG_STATEMOVE: | |||
case JTAG_STATEMOVE: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); | |||
LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); | |||
#endif | |||
bitq_end_state(cmd->cmd.statemove->end_state); | |||
bitq_state_move(end_state); /* uncoditional TAP move */ | |||
break; | |||
bitq_end_state(cmd->cmd.statemove->end_state); | |||
bitq_state_move( tap_get_end_state() ); /* uncoditional TAP move */ | |||
break; | |||
case JTAG_PATHMOVE: | |||
case JTAG_PATHMOVE: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); | |||
LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, | |||
cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); | |||
#endif | |||
bitq_path_move(cmd->cmd.pathmove); | |||
break; | |||
bitq_path_move(cmd->cmd.pathmove); | |||
break; | |||
case JTAG_SCAN: | |||
case JTAG_SCAN: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("scan end in %i", cmd->cmd.scan->end_state); | |||
if (cmd->cmd.scan->ir_scan) LOG_DEBUG("scan ir"); | |||
else LOG_DEBUG("scan dr"); | |||
LOG_DEBUG("scan end in %i", cmd->cmd.scan->end_state); | |||
if (cmd->cmd.scan->ir_scan) | |||
LOG_DEBUG("scan ir"); | |||
else | |||
LOG_DEBUG("scan dr"); | |||
#endif | |||
bitq_end_state(cmd->cmd.scan->end_state); | |||
bitq_scan(cmd->cmd.scan); | |||
if (cur_state != end_state) bitq_state_move(end_state); | |||
break; | |||
bitq_end_state(cmd->cmd.scan->end_state); | |||
bitq_scan(cmd->cmd.scan); | |||
if ( tap_get_state() != tap_get_end_state() ) | |||
bitq_state_move( tap_get_end_state() ); | |||
break; | |||
case JTAG_SLEEP: | |||
case JTAG_SLEEP: | |||
#ifdef _DEBUG_JTAG_IO_ | |||
LOG_DEBUG("sleep %i", cmd->cmd.sleep->us); | |||
LOG_DEBUG("sleep %i", cmd->cmd.sleep->us); | |||
#endif | |||
bitq_interface->sleep(cmd->cmd.sleep->us); | |||
if (bitq_interface->in_rdy()) bitq_in_proc(); | |||
break; | |||
bitq_interface->sleep(cmd->cmd.sleep->us); | |||
if ( bitq_interface->in_rdy() ) | |||
bitq_in_proc(); | |||
break; | |||
default: | |||
LOG_ERROR("BUG: unknown JTAG command type encountered"); | |||
exit(-1); | |||
default: | |||
LOG_ERROR("BUG: unknown JTAG command type encountered"); | |||
exit(-1); | |||
} | |||
cmd = cmd->next; | |||
@@ -335,11 +389,13 @@ int bitq_execute_queue(void) | |||
bitq_interface->flush(); | |||
bitq_in_proc(); | |||
if (bitq_in_state.cmd) { | |||
if (bitq_in_state.cmd) | |||
{ | |||
LOG_ERROR("missing data from bitq interface"); | |||
return ERROR_JTAG_QUEUE_FAILED; | |||
} | |||
if (bitq_interface->in()>=0) { | |||
if (bitq_interface->in()>=0) | |||
{ | |||
LOG_ERROR("extra data from bitq interface"); | |||
return ERROR_JTAG_QUEUE_FAILED; | |||
} | |||
@@ -347,11 +403,12 @@ int bitq_execute_queue(void) | |||
return bitq_in_state.status; | |||
} | |||
void bitq_cleanup(void) | |||
{ | |||
if (bitq_in_buffer!=NULL) | |||
{ | |||
free(bitq_in_buffer); | |||
bitq_in_buffer=NULL; | |||
bitq_in_buffer = NULL; | |||
} | |||
} |
@@ -34,9 +34,6 @@ static int dummy_clock; /* edge detector */ | |||
static int clock_count; /* count clocks in any stable state, only stable states */ | |||
static tap_state_t tap_state_transition(tap_state_t cur_state, int tms); | |||
static u32 dummy_data; | |||
@@ -105,7 +102,7 @@ void dummy_write(int tck, int tms, int tdi) | |||
clock_count = 0; | |||
} | |||
LOG_DEBUG("dummy_tap: %s", jtag_state_name(dummy_state) ); | |||
LOG_DEBUG("dummy_tap: %s", tap_state_name(dummy_state) ); | |||
#if defined(DEBUG) | |||
if(dummy_state == TAP_DRCAPTURE) | |||
@@ -131,7 +128,7 @@ void dummy_reset(int trst, int srst) | |||
if (trst || (srst && (jtag_reset_config & RESET_SRST_PULLS_TRST))) | |||
dummy_state = TAP_RESET; | |||
LOG_DEBUG("reset to: %s", jtag_state_name(dummy_state) ); | |||
LOG_DEBUG("reset to: %s", tap_state_name(dummy_state) ); | |||
} | |||
static int dummy_khz(int khz, int *jtag_speed) | |||
@@ -187,106 +184,3 @@ void dummy_led(int on) | |||
{ | |||
} | |||
/** | |||
* Function tap_state_transition | |||
* takes a current TAP state and returns the next state according to the tms value. | |||
* | |||
* Even though there is code to duplicate this elsewhere, we do it here a little | |||
* differently just to get a second opinion, i.e. a verification, on state tracking | |||
* in that other logic. Plus array lookups without index checking are no favorite thing. | |||
* This is educational for developers new to TAP controllers. | |||
*/ | |||
static tap_state_t tap_state_transition(tap_state_t cur_state, int tms) | |||
{ | |||
tap_state_t new_state; | |||
if (tms) | |||
{ | |||
switch (cur_state) | |||
{ | |||
case TAP_RESET: | |||
new_state = cur_state; | |||
break; | |||
case TAP_IDLE: | |||
case TAP_DRUPDATE: | |||
case TAP_IRUPDATE: | |||
new_state = TAP_DRSELECT; | |||
break; | |||
case TAP_DRSELECT: | |||
new_state = TAP_IRSELECT; | |||
break; | |||
case TAP_DRCAPTURE: | |||
case TAP_DRSHIFT: | |||
new_state = TAP_DREXIT1; | |||
break; | |||
case TAP_DREXIT1: | |||
case TAP_DREXIT2: | |||
new_state = TAP_DRUPDATE; | |||
break; | |||
case TAP_DRPAUSE: | |||
new_state = TAP_DREXIT2; | |||
break; | |||
case TAP_IRSELECT: | |||
new_state = TAP_RESET; | |||
break; | |||
case TAP_IRCAPTURE: | |||
case TAP_IRSHIFT: | |||
new_state = TAP_IREXIT1; | |||
break; | |||
case TAP_IREXIT1: | |||
case TAP_IREXIT2: | |||
new_state = TAP_IRUPDATE; | |||
break; | |||
case TAP_IRPAUSE: | |||
new_state = TAP_IREXIT2; | |||
break; | |||
default: | |||
LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state ); | |||
exit(1); | |||
break; | |||
} | |||
} | |||
else | |||
{ | |||
switch (cur_state) | |||
{ | |||
case TAP_RESET: | |||
case TAP_IDLE: | |||
case TAP_DRUPDATE: | |||
case TAP_IRUPDATE: | |||
new_state = TAP_IDLE; | |||
break; | |||
case TAP_DRSELECT: | |||
new_state = TAP_DRCAPTURE; | |||
break; | |||
case TAP_DRCAPTURE: | |||
case TAP_DRSHIFT: | |||
case TAP_DREXIT2: | |||
new_state = TAP_DRSHIFT; | |||
break; | |||
case TAP_DREXIT1: | |||
case TAP_DRPAUSE: | |||
new_state = TAP_DRPAUSE; | |||
break; | |||
case TAP_IRSELECT: | |||
new_state = TAP_IRCAPTURE; | |||
break; | |||
case TAP_IRCAPTURE: | |||
case TAP_IRSHIFT: | |||
case TAP_IREXIT2: | |||
new_state = TAP_IRSHIFT; | |||
break; | |||
case TAP_IREXIT1: | |||
case TAP_IRPAUSE: | |||
new_state = TAP_IRPAUSE; | |||
break; | |||
default: | |||
LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state ); | |||
exit(1); | |||
break; | |||
} | |||
} | |||
return new_state; | |||
} |
@@ -196,8 +196,8 @@ int gw16012_speed(int speed) | |||
void gw16012_end_state(int state) | |||
{ | |||
if (tap_move_map[state] != -1) | |||
end_state = state; | |||
if (tap_is_state_stable(state)) | |||
tap_set_end_state(state); | |||
else | |||
{ | |||
LOG_ERROR("BUG: %i is not a valid end state", state); | |||
@@ -208,7 +208,7 @@ void gw16012_end_state(int state) | |||
void gw16012_state_move(void) | |||
{ | |||
int i=0, tms=0; | |||
u8 tms_scan = TAP_MOVE(cur_state, end_state); | |||
u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); | |||
gw16012_control(0x0); /* single-bit mode */ | |||
@@ -218,7 +218,7 @@ void gw16012_state_move(void) | |||
gw16012_data(tms << 1); /* output next TMS bit */ | |||
} | |||
cur_state = end_state; | |||
tap_set_state(tap_get_end_state()); | |||
} | |||
void gw16012_path_move(pathmove_command_t *cmd) | |||
@@ -230,35 +230,35 @@ void gw16012_path_move(pathmove_command_t *cmd) | |||
while (num_states) | |||
{ | |||
gw16012_control(0x0); /* single-bit mode */ | |||
if (tap_transitions[cur_state].low == cmd->path[state_count]) | |||
if (tap_state_transition(tap_get_state(), FALSE) == cmd->path[state_count]) | |||
{ | |||
gw16012_data(0x0); /* TCK cycle with TMS low */ | |||
} | |||
else if (tap_transitions[cur_state].high == cmd->path[state_count]) | |||
else if (tap_state_transition(tap_get_state(), TRUE) == cmd->path[state_count]) | |||
{ | |||
gw16012_data(0x2); /* TCK cycle with TMS high */ | |||
} | |||
else | |||
{ | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(cmd->path[state_count])); | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count])); | |||
exit(-1); | |||
} | |||
cur_state = cmd->path[state_count]; | |||
tap_set_state(cmd->path[state_count]); | |||
state_count++; | |||
num_states--; | |||
} | |||
end_state = cur_state; | |||
tap_set_end_state(tap_get_state()); | |||
} | |||
void gw16012_runtest(int num_cycles) | |||
{ | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
int i; | |||
/* only do a state_move when we're not already in IDLE */ | |||
if (cur_state != TAP_IDLE) | |||
if (tap_get_state() != TAP_IDLE) | |||
{ | |||
gw16012_end_state(TAP_IDLE); | |||
gw16012_state_move(); | |||
@@ -271,7 +271,7 @@ void gw16012_runtest(int num_cycles) | |||
} | |||
gw16012_end_state(saved_end_state); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
gw16012_state_move(); | |||
} | |||
@@ -279,11 +279,11 @@ void gw16012_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) | |||
{ | |||
int bits_left = scan_size; | |||
int bit_count = 0; | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
u8 scan_out, scan_in; | |||
/* only if we're not already in the correct Shift state */ | |||
if (!((!ir_scan && (cur_state == TAP_DRSHIFT)) || (ir_scan && (cur_state == TAP_IRSHIFT)))) | |||
if (!((!ir_scan && (tap_get_state() == TAP_DRSHIFT)) || (ir_scan && (tap_get_state() == TAP_IRSHIFT)))) | |||
{ | |||
if (ir_scan) | |||
gw16012_end_state(TAP_IRSHIFT); | |||
@@ -312,8 +312,8 @@ void gw16012_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) | |||
if (bits_left == 0) /* last bit */ | |||
{ | |||
if ((ir_scan && (end_state == TAP_IRSHIFT)) | |||
|| (!ir_scan && (end_state == TAP_DRSHIFT))) | |||
if ((ir_scan && (tap_get_end_state() == TAP_IRSHIFT)) | |||
|| (!ir_scan && (tap_get_end_state() == TAP_DRSHIFT))) | |||
{ | |||
tms = 0; | |||
} | |||
@@ -334,16 +334,16 @@ void gw16012_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) | |||
bit_count++; | |||
} | |||
if (!((ir_scan && (end_state == TAP_IRSHIFT)) || | |||
(!ir_scan && (end_state == TAP_DRSHIFT)))) | |||
if (!((ir_scan && (tap_get_end_state() == TAP_IRSHIFT)) || | |||
(!ir_scan && (tap_get_end_state() == TAP_DRSHIFT)))) | |||
{ | |||
gw16012_data(0x0); | |||
if (ir_scan) | |||
cur_state = TAP_IRPAUSE; | |||
tap_set_state(TAP_IRPAUSE); | |||
else | |||
cur_state = TAP_DRPAUSE; | |||
tap_set_state(TAP_DRPAUSE); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
gw16012_state_move(); | |||
} | |||
} | |||
@@ -378,7 +378,7 @@ int gw16012_execute_queue(void) | |||
#endif | |||
if (cmd->cmd.reset->trst == 1) | |||
{ | |||
cur_state = TAP_RESET; | |||
tap_set_state(TAP_RESET); | |||
} | |||
gw16012_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
break; | |||
@@ -88,9 +88,9 @@ int jlink_quit(void); | |||
int jlink_handle_jlink_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); | |||
/* Queue command functions */ | |||
void jlink_end_state(enum tap_state state); | |||
void jlink_end_state(tap_state_t state); | |||
void jlink_state_move(void); | |||
void jlink_path_move(int num_states, enum tap_state *path); | |||
void jlink_path_move(int num_states, tap_state_t *path); | |||
void jlink_runtest(int num_cycles); | |||
void jlink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command); | |||
void jlink_reset(int trst, int srst); | |||
@@ -214,7 +214,7 @@ int jlink_execute_queue(void) | |||
if (cmd->cmd.reset->trst == 1) | |||
{ | |||
cur_state = TAP_RESET; | |||
tap_set_state(TAP_RESET); | |||
} | |||
jlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
break; | |||
@@ -331,11 +331,11 @@ int jlink_quit(void) | |||
/***************************************************************************/ | |||
/* Queue command implementations */ | |||
void jlink_end_state(enum tap_state state) | |||
void jlink_end_state(tap_state_t state) | |||
{ | |||
if (tap_move_map[state] != -1) | |||
if (tap_is_state_stable(state)) | |||
{ | |||
end_state = state; | |||
tap_set_end_state(state); | |||
} | |||
else | |||
{ | |||
@@ -349,7 +349,7 @@ void jlink_state_move(void) | |||
{ | |||
int i; | |||
int tms = 0; | |||
u8 tms_scan = TAP_MOVE(cur_state, end_state); | |||
u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); | |||
for (i = 0; i < 7; i++) | |||
{ | |||
@@ -357,43 +357,43 @@ void jlink_state_move(void) | |||
jlink_tap_append_step(tms, 0); | |||
} | |||
cur_state = end_state; | |||
tap_set_state(tap_get_end_state()); | |||
} | |||
void jlink_path_move(int num_states, enum tap_state *path) | |||
void jlink_path_move(int num_states, tap_state_t *path) | |||
{ | |||
int i; | |||
for (i = 0; i < num_states; i++) | |||
{ | |||
if (path[i] == tap_transitions[cur_state].low) | |||
if (path[i] == tap_state_transition(tap_get_state(), FALSE)) | |||
{ | |||
jlink_tap_append_step(0, 0); | |||
} | |||
else if (path[i] == tap_transitions[cur_state].high) | |||
else if (path[i] == tap_state_transition(tap_get_state(), TRUE)) | |||
{ | |||
jlink_tap_append_step(1, 0); | |||
} | |||
else | |||
{ | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(path[i])); | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i])); | |||
exit(-1); | |||
} | |||
cur_state = path[i]; | |||
tap_set_state(path[i]); | |||
} | |||
end_state = cur_state; | |||
tap_set_end_state(tap_get_state()); | |||
} | |||
void jlink_runtest(int num_cycles) | |||
{ | |||
int i; | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
/* only do a state_move when we're not already in IDLE */ | |||
if (cur_state != TAP_IDLE) | |||
if (tap_get_state() != TAP_IDLE) | |||
{ | |||
jlink_end_state(TAP_IDLE); | |||
jlink_state_move(); | |||
@@ -407,7 +407,7 @@ void jlink_runtest(int num_cycles) | |||
/* finish in end_state */ | |||
jlink_end_state(saved_end_state); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
{ | |||
jlink_state_move(); | |||
} | |||
@@ -415,11 +415,11 @@ void jlink_runtest(int num_cycles) | |||
void jlink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command) | |||
{ | |||
enum tap_state saved_end_state; | |||
tap_state_t saved_end_state; | |||
jlink_tap_ensure_space(1, scan_size + 8); | |||
saved_end_state = end_state; | |||
saved_end_state = tap_get_end_state(); | |||
/* Move to appropriate scan state */ | |||
jlink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT); | |||
@@ -433,9 +433,9 @@ void jlink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, sca | |||
/* We are in Exit1, go to Pause */ | |||
jlink_tap_append_step(0, 0); | |||
cur_state = ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE; | |||
tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
{ | |||
jlink_state_move(); | |||
} | |||
@@ -4,6 +4,10 @@ | |||
* * | |||
* Copyright (C) 2007,2008 Øyvind Harboe * | |||
* oyvind.harboe@zylin.com * | |||
* | |||
* Copyright (C) 2009 SoftPLC Corporation | |||
* http://softplc.com | |||
* dick@softplc.com | |||
* * | |||
* This program is free software; you can redistribute it and/or modify * | |||
* it under the terms of the GNU General Public License as published by * | |||
@@ -51,52 +55,6 @@ typedef struct cmd_queue_page_s | |||
#define CMD_QUEUE_PAGE_SIZE (1024 * 1024) | |||
static cmd_queue_page_t *cmd_queue_pages = NULL; | |||
/* tap_move[i][j]: tap movement command to go from state i to state j | |||
* 0: Test-Logic-Reset | |||
* 1: Run-Test/Idle | |||
* 2: Shift-DR | |||
* 3: Pause-DR | |||
* 4: Shift-IR | |||
* 5: Pause-IR | |||
* | |||
* DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code | |||
*/ | |||
u8 tap_move[6][6] = | |||
{ | |||
/* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ | |||
{ 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* RESET */ | |||
{ 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* IDLE */ | |||
{ 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* DRSHIFT */ | |||
{ 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* DRPAUSE */ | |||
{ 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* IRSHIFT */ | |||
{ 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* IRPAUSE */ | |||
}; | |||
int tap_move_map[16] = { | |||
0, -1, -1, 2, -1, 3, -1, -1, | |||
1, -1, -1, 4, -1, 5, -1, -1 | |||
}; | |||
tap_transition_t tap_transitions[16] = | |||
{ | |||
{TAP_RESET, TAP_IDLE}, /* RESET */ | |||
{TAP_IRSELECT, TAP_DRCAPTURE}, /* DRSELECT */ | |||
{TAP_DREXIT1, TAP_DRSHIFT}, /* DRCAPTURE */ | |||
{TAP_DREXIT1, TAP_DRSHIFT}, /* DRSHIFT */ | |||
{TAP_DRUPDATE, TAP_DRPAUSE}, /* DREXIT1 */ | |||
{TAP_DREXIT2, TAP_DRPAUSE}, /* DRPAUSE */ | |||
{TAP_DRUPDATE, TAP_DRSHIFT}, /* DREXIT2 */ | |||
{TAP_DRSELECT, TAP_IDLE}, /* DRUPDATE */ | |||
{TAP_DRSELECT, TAP_IDLE}, /* IDLE */ | |||
{TAP_RESET, TAP_IRCAPTURE}, /* IRSELECT */ | |||
{TAP_IREXIT1, TAP_IRSHIFT}, /* IRCAPTURE */ | |||
{TAP_IREXIT1, TAP_IRSHIFT}, /* IRSHIFT */ | |||
{TAP_IRUPDATE, TAP_IRPAUSE}, /* IREXIT1 */ | |||
{TAP_IREXIT2, TAP_IRPAUSE}, /* IRPAUSE */ | |||
{TAP_IRUPDATE, TAP_IRSHIFT}, /* IREXIT2 */ | |||
{TAP_DRSELECT, TAP_IDLE} /* IRUPDATE */ | |||
}; | |||
char* jtag_event_strings[] = | |||
{ | |||
"JTAG controller reset (RESET or TRST)" | |||
@@ -109,13 +67,6 @@ const Jim_Nvp nvp_jtag_tap_event[] = { | |||
{ .name = NULL, .value = -1 } | |||
}; | |||
/* kludge!!!! these are just global variables that the | |||
* interface use internally. They really belong | |||
* inside the drivers, but we don't want to break | |||
* linking the drivers!!!! | |||
*/ | |||
enum tap_state end_state = TAP_RESET; | |||
enum tap_state cur_state = TAP_RESET; | |||
int jtag_trst = 0; | |||
int jtag_srst = 0; | |||
@@ -124,8 +75,8 @@ jtag_command_t **last_comand_pointer = &jtag_command_queue; | |||
static jtag_tap_t *jtag_all_taps = NULL; | |||
enum reset_types jtag_reset_config = RESET_NONE; | |||
enum tap_state cmd_queue_end_state = TAP_RESET; | |||
enum tap_state cmd_queue_cur_state = TAP_RESET; | |||
tap_state_t cmd_queue_end_state = TAP_RESET; | |||
tap_state_t cmd_queue_cur_state = TAP_RESET; | |||
int jtag_verify_capture_ir = 1; | |||
@@ -257,9 +208,9 @@ jtag_interface_t *jtag_interface = NULL; | |||
int jtag_speed = 0; | |||
/* forward declarations */ | |||
void jtag_add_pathmove(int num_states, enum tap_state *path); | |||
void jtag_add_runtest(int num_cycles, enum tap_state endstate); | |||
void jtag_add_end_state(enum tap_state endstate); | |||
void jtag_add_pathmove(int num_states, tap_state_t *path); | |||
void jtag_add_runtest(int num_cycles, tap_state_t endstate); | |||
void jtag_add_end_state(tap_state_t endstate); | |||
void jtag_add_sleep(u32 us); | |||
int jtag_execute_queue(void); | |||
@@ -550,7 +501,7 @@ static void jtag_prelude1(void) | |||
jtag_call_event_callbacks(JTAG_TRST_ASSERTED); | |||
} | |||
static void jtag_prelude(enum tap_state state) | |||
static void jtag_prelude(tap_state_t state) | |||
{ | |||
jtag_prelude1(); | |||
@@ -560,7 +511,7 @@ static void jtag_prelude(enum tap_state state) | |||
cmd_queue_cur_state = cmd_queue_end_state; | |||
} | |||
void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) | |||
void jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
int retval; | |||
@@ -571,7 +522,7 @@ void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state | |||
jtag_error=retval; | |||
} | |||
int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
jtag_command_t **last_cmd; | |||
jtag_tap_t *tap; | |||
@@ -657,7 +608,7 @@ int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, | |||
return ERROR_OK; | |||
} | |||
void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) | |||
void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
int retval; | |||
@@ -668,7 +619,7 @@ void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state | |||
jtag_error=retval; | |||
} | |||
int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
int i; | |||
jtag_command_t **last_cmd; | |||
@@ -704,7 +655,7 @@ int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *f | |||
return ERROR_OK; | |||
} | |||
void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) | |||
void jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
int retval; | |||
@@ -715,7 +666,7 @@ void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state | |||
jtag_error=retval; | |||
} | |||
int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
int j; | |||
int nth_tap; | |||
@@ -818,7 +769,7 @@ void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap, | |||
int num_fields, | |||
const int *num_bits, | |||
const u32 *value, | |||
enum tap_state end_state) | |||
tap_state_t end_state) | |||
{ | |||
int nth_tap; | |||
int field_count = 0; | |||
@@ -912,7 +863,7 @@ void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap, | |||
} | |||
} | |||
void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) | |||
void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
int retval; | |||
@@ -923,7 +874,7 @@ void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state | |||
jtag_error=retval; | |||
} | |||
int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
int i; | |||
jtag_command_t **last_cmd = jtag_get_last_command_p(); | |||
@@ -971,7 +922,7 @@ void jtag_add_tlr(void) | |||
int MINIDRIVER(interface_jtag_add_tlr)(void) | |||
{ | |||
enum tap_state state = TAP_RESET; | |||
tap_state_t state = TAP_RESET; | |||
jtag_command_t **last_cmd = jtag_get_last_command_p(); | |||
/* allocate memory for a new list member */ | |||
@@ -986,14 +937,14 @@ int MINIDRIVER(interface_jtag_add_tlr)(void) | |||
return ERROR_OK; | |||
} | |||
void jtag_add_pathmove(int num_states, enum tap_state *path) | |||
void jtag_add_pathmove(int num_states, tap_state_t *path) | |||
{ | |||
enum tap_state cur_state=cmd_queue_cur_state; | |||
tap_state_t cur_state=cmd_queue_cur_state; | |||
int i; | |||
int retval; | |||
/* the last state has to be a stable state */ | |||
if (tap_move_map[path[num_states - 1]] == -1) | |||
if (!tap_is_state_stable(path[num_states - 1])) | |||
{ | |||
LOG_ERROR("BUG: TAP path doesn't finish in a stable state"); | |||
exit(-1); | |||
@@ -1006,10 +957,10 @@ void jtag_add_pathmove(int num_states, enum tap_state *path) | |||
LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences"); | |||
exit(-1); | |||
} | |||
if ((tap_transitions[cur_state].low != path[i])&& | |||
(tap_transitions[cur_state].high != path[i])) | |||
if ( tap_state_transition(cur_state, TRUE) != path[i] | |||
&& tap_state_transition(cur_state, FALSE) != path[i]) | |||
{ | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(path[i])); | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i])); | |||
exit(-1); | |||
} | |||
cur_state = path[i]; | |||
@@ -1023,7 +974,7 @@ void jtag_add_pathmove(int num_states, enum tap_state *path) | |||
jtag_error=retval; | |||
} | |||
int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path) | |||
int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, tap_state_t *path) | |||
{ | |||
jtag_command_t **last_cmd = jtag_get_last_command_p(); | |||
int i; | |||
@@ -1036,7 +987,7 @@ int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path | |||
(*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t)); | |||
(*last_cmd)->cmd.pathmove->num_states = num_states; | |||
(*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states); | |||
(*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states); | |||
for (i = 0; i < num_states; i++) | |||
(*last_cmd)->cmd.pathmove->path[i] = path[i]; | |||
@@ -1044,7 +995,7 @@ int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path | |||
return ERROR_OK; | |||
} | |||
int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state) | |||
int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state) | |||
{ | |||
jtag_command_t **last_cmd = jtag_get_last_command_p(); | |||
@@ -1061,7 +1012,7 @@ int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state) | |||
return ERROR_OK; | |||
} | |||
void jtag_add_runtest(int num_cycles, enum tap_state state) | |||
void jtag_add_runtest(int num_cycles, tap_state_t state) | |||
{ | |||
int retval; | |||
@@ -1093,19 +1044,10 @@ void jtag_add_clocks( int num_cycles ) | |||
{ | |||
int retval; | |||
/* "if (tap_move_map[cm_queue_cur_state] != -1)" is of no help when cur_state==TAP_IDLE */ | |||
switch(cmd_queue_cur_state) | |||
if( !tap_is_state_stable(cmd_queue_cur_state) ) | |||
{ | |||
case TAP_DRSHIFT: | |||
case TAP_IDLE: | |||
case TAP_RESET: | |||
case TAP_DRPAUSE: | |||
case TAP_IRSHIFT: | |||
case TAP_IRPAUSE: | |||
break; /* above stable states are OK */ | |||
default: | |||
LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"", | |||
jtag_state_name(cmd_queue_cur_state) ); | |||
tap_state_name(cmd_queue_cur_state) ); | |||
jtag_error = ERROR_JTAG_NOT_STABLE_STATE; | |||
return; | |||
} | |||
@@ -1114,8 +1056,8 @@ void jtag_add_clocks( int num_cycles ) | |||
{ | |||
jtag_prelude1(); | |||
retval=interface_jtag_add_clocks(num_cycles); | |||
if (retval!=ERROR_OK) | |||
retval = interface_jtag_add_clocks(num_cycles); | |||
if (retval != ERROR_OK) | |||
jtag_error=retval; | |||
} | |||
} | |||
@@ -1240,7 +1182,7 @@ int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst) | |||
return ERROR_OK; | |||
} | |||
void jtag_add_end_state(enum tap_state state) | |||
void jtag_add_end_state(tap_state_t state) | |||
{ | |||
cmd_queue_end_state = state; | |||
if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT)) | |||
@@ -2708,7 +2650,7 @@ int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char * | |||
int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) | |||
{ | |||
enum tap_state state; | |||
tap_state_t state; | |||
if (argc < 1) | |||
{ | |||
@@ -2718,14 +2660,14 @@ int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char * | |||
{ | |||
for (state = 0; state < 16; state++) | |||
{ | |||
if (strcmp(args[0], jtag_state_name(state)) == 0) | |||
if (strcmp(args[0], tap_state_name(state)) == 0) | |||
{ | |||
jtag_add_end_state(state); | |||
jtag_execute_queue(); | |||
} | |||
} | |||
} | |||
command_print(cmd_ctx, "current endstate: %s", jtag_state_name(cmd_queue_end_state)); | |||
command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state)); | |||
return ERROR_OK; | |||
} | |||
@@ -2979,8 +2921,247 @@ void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e) | |||
} | |||
/* map state number to SVF state string */ | |||
const char* jtag_state_name(enum tap_state state) | |||
/*-----<Cable Helper API>---------------------------------------*/ | |||
/* these Cable Helper API functions are all documented in the jtag.h header file, | |||
using a Doxygen format. And since Doxygen's configuration file "Doxyfile", | |||
is setup to prefer its docs in the header file, no documentation is here, for | |||
if it were, it would have to be doubly maintained. | |||
*/ | |||
/** | |||
* @see tap_set_state() and tap_get_state() accessors. | |||
* Actual name is not important since accessors hide it. | |||
*/ | |||
static tap_state_t state_follower = TAP_RESET; | |||
void tap_set_state_impl( tap_state_t new_state ) | |||
{ | |||
/* this is the state we think the TAPs are in now, was cur_state */ | |||
state_follower = new_state; | |||
} | |||
tap_state_t tap_get_state() | |||
{ | |||
return state_follower; | |||
} | |||
/** | |||
* @see tap_set_end_state() and tap_get_end_state() accessors. | |||
* Actual name is not important because accessors hide it. | |||
*/ | |||
static tap_state_t end_state_follower = TAP_RESET; | |||
void tap_set_end_state( tap_state_t new_end_state ) | |||
{ | |||
/* this is the state we think the TAPs will be in at completion of the | |||
current TAP operation, was end_state | |||
*/ | |||
end_state_follower = new_end_state; | |||
} | |||
tap_state_t tap_get_end_state() | |||
{ | |||
return end_state_follower; | |||
} | |||
int tap_move_ndx( tap_state_t astate ) | |||
{ | |||
/* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */ | |||
/* old version | |||
const static int move_map[16] = | |||
{ | |||
0, -1, -1, 2, -1, 3, -1, -1, | |||
1, -1, -1, 4, -1, 5, -1, -1 | |||
}; | |||
*/ | |||
int ndx; | |||
switch( astate ) | |||
{ | |||
case TAP_RESET: ndx = 0; break; | |||
case TAP_DRSHIFT: ndx = 2; break; | |||
case TAP_DRPAUSE: ndx = 3; break; | |||
case TAP_IDLE: ndx = 1; break; | |||
case TAP_IRSHIFT: ndx = 4; break; | |||
case TAP_IRPAUSE: ndx = 5; break; | |||
default: | |||
LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) ); | |||
exit(1); | |||
} | |||
return ndx; | |||
} | |||
int tap_get_tms_path( tap_state_t from, tap_state_t to ) | |||
{ | |||
/* tap_move[i][j]: tap movement command to go from state i to state j | |||
* 0: Test-Logic-Reset | |||
* 1: Run-Test/Idle | |||
* 2: Shift-DR | |||
* 3: Pause-DR | |||
* 4: Shift-IR | |||
* 5: Pause-IR | |||
* | |||
* DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code | |||
*/ | |||
const static u8 tms_seqs[6][6] = | |||
{ | |||
/* value clocked to TMS to move from one of six stable states to another */ | |||
/* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ | |||
{ 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16 }, /* RESET */ | |||
{ 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b }, /* IDLE */ | |||
{ 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f }, /* DRSHIFT */ | |||
{ 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f }, /* DRPAUSE */ | |||
{ 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01 }, /* IRSHIFT */ | |||
{ 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f } /* IRPAUSE */ | |||
}; | |||
if( !tap_is_state_stable(from) ) | |||
{ | |||
LOG_ERROR( "fatal: tap_state \"from\" (=%s) is not stable", tap_state_name(from) ); | |||
exit(1); | |||
} | |||
if( !tap_is_state_stable(to) ) | |||
{ | |||
LOG_ERROR( "fatal: tap_state \"to\" (=%s) is not stable", tap_state_name(to) ); | |||
exit(1); | |||
} | |||
/* @todo: support other than 7 clocks ? */ | |||
return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)]; | |||
} | |||
BOOL tap_is_state_stable(tap_state_t astate) | |||
{ | |||
BOOL is_stable; | |||
/* A switch() is used because it is symbol dependent | |||
(not value dependent like an array), and can also check bounds. | |||
*/ | |||
switch( astate ) | |||
{ | |||
case TAP_RESET: | |||
case TAP_IDLE: | |||
case TAP_DRSHIFT: | |||
case TAP_DRPAUSE: | |||
case TAP_IRSHIFT: | |||
case TAP_IRPAUSE: | |||
is_stable = TRUE; | |||
break; | |||
default: | |||
is_stable = FALSE; | |||
} | |||
return is_stable; | |||
} | |||
tap_state_t tap_state_transition(tap_state_t cur_state, BOOL tms) | |||
{ | |||
tap_state_t new_state; | |||
/* A switch is used because it is symbol dependent and not value dependent | |||
like an array. Also it can check for out of range conditions. | |||
*/ | |||
if (tms) | |||
{ | |||
switch (cur_state) | |||
{ | |||
case TAP_RESET: | |||
new_state = cur_state; | |||
break; | |||
case TAP_IDLE: | |||
case TAP_DRUPDATE: | |||
case TAP_IRUPDATE: | |||
new_state = TAP_DRSELECT; | |||
break; | |||
case TAP_DRSELECT: | |||
new_state = TAP_IRSELECT; | |||
break; | |||
case TAP_DRCAPTURE: | |||
case TAP_DRSHIFT: | |||
new_state = TAP_DREXIT1; | |||
break; | |||
case TAP_DREXIT1: | |||
case TAP_DREXIT2: | |||
new_state = TAP_DRUPDATE; | |||
break; | |||
case TAP_DRPAUSE: | |||
new_state = TAP_DREXIT2; | |||
break; | |||
case TAP_IRSELECT: | |||
new_state = TAP_RESET; | |||
break; | |||
case TAP_IRCAPTURE: | |||
case TAP_IRSHIFT: | |||
new_state = TAP_IREXIT1; | |||
break; | |||
case TAP_IREXIT1: | |||
case TAP_IREXIT2: | |||
new_state = TAP_IRUPDATE; | |||
break; | |||
case TAP_IRPAUSE: | |||
new_state = TAP_IREXIT2; | |||
break; | |||
default: | |||
LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state ); | |||
exit(1); | |||
break; | |||
} | |||
} | |||
else | |||
{ | |||
switch (cur_state) | |||
{ | |||
case TAP_RESET: | |||
case TAP_IDLE: | |||
case TAP_DRUPDATE: | |||
case TAP_IRUPDATE: | |||
new_state = TAP_IDLE; | |||
break; | |||
case TAP_DRSELECT: | |||
new_state = TAP_DRCAPTURE; | |||
break; | |||
case TAP_DRCAPTURE: | |||
case TAP_DRSHIFT: | |||
case TAP_DREXIT2: | |||
new_state = TAP_DRSHIFT; | |||
break; | |||
case TAP_DREXIT1: | |||
case TAP_DRPAUSE: | |||
new_state = TAP_DRPAUSE; | |||
break; | |||
case TAP_IRSELECT: | |||
new_state = TAP_IRCAPTURE; | |||
break; | |||
case TAP_IRCAPTURE: | |||
case TAP_IRSHIFT: | |||
case TAP_IREXIT2: | |||
new_state = TAP_IRSHIFT; | |||
break; | |||
case TAP_IREXIT1: | |||
case TAP_IRPAUSE: | |||
new_state = TAP_IRPAUSE; | |||
break; | |||
default: | |||
LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state ); | |||
exit(1); | |||
break; | |||
} | |||
} | |||
return new_state; | |||
} | |||
const char* tap_state_name(tap_state_t state) | |||
{ | |||
const char* ret; | |||
@@ -3008,3 +3189,4 @@ const char* jtag_state_name(enum tap_state state) | |||
return ret; | |||
} | |||
/*-----</Cable Helper API>--------------------------------------*/ |
@@ -1,25 +1,25 @@ | |||
/*************************************************************************** | |||
* Copyright (C) 2005 by Dominic Rath * | |||
* Dominic.Rath@gmx.de * | |||
* * | |||
* Copyright (C) 2007,2008 Øyvind Harboe * | |||
* oyvind.harboe@zylin.com * | |||
* * | |||
* This program is free software; you can redistribute it and/or modify * | |||
* it under the terms of the GNU General Public License as published by * | |||
* the Free Software Foundation; either version 2 of the License, or * | |||
* (at your option) any later version. * | |||
* * | |||
* This program is distributed in the hope that it will be useful, * | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of * | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * | |||
* 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. * | |||
***************************************************************************/ | |||
* Copyright (C) 2005 by Dominic Rath * | |||
* Dominic.Rath@gmx.de * | |||
* * | |||
* Copyright (C) 2007,2008 Øyvind Harboe * | |||
* oyvind.harboe@zylin.com * | |||
* * | |||
* This program is free software; you can redistribute it and/or modify * | |||
* it under the terms of the GNU General Public License as published by * | |||
* the Free Software Foundation; either version 2 of the License, or * | |||
* (at your option) any later version. * | |||
* * | |||
* This program is distributed in the hope that it will be useful, * | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of * | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * | |||
* 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. * | |||
***************************************************************************/ | |||
#ifndef JTAG_H | |||
#define JTAG_H | |||
@@ -35,141 +35,253 @@ | |||
#endif | |||
#ifndef DEBUG_JTAG_IOZ | |||
#define DEBUG_JTAG_IOZ 64 | |||
#define DEBUG_JTAG_IOZ 64 | |||
#endif | |||
/* 16 Tap States, from page 21 of ASSET InterTech, Inc.'s svf.pdf | |||
*/ | |||
typedef enum tap_state | |||
{ | |||
TAP_RESET = 0x0, TAP_IDLE = 0x8, | |||
TAP_DRSELECT = 0x1, TAP_DRCAPTURE = 0x2, TAP_DRSHIFT = 0x3, TAP_DREXIT1 = 0x4, | |||
TAP_DRPAUSE = 0x5, TAP_DREXIT2 = 0x6, TAP_DRUPDATE = 0x7, | |||
TAP_IRSELECT = 0x9, TAP_IRCAPTURE = 0xa, TAP_IRSHIFT = 0xb, TAP_IREXIT1 = 0xc, | |||
TAP_IRPAUSE = 0xd, TAP_IREXIT2 = 0xe, TAP_IRUPDATE = 0xf | |||
} tap_state_t; | |||
enum tap_state { | |||
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; | |||
typedef unsigned BOOL; | |||
#define TRUE 1 | |||
#define FALSE 0 | |||
typedef struct tap_transition_s | |||
{ | |||
enum tap_state high; | |||
enum tap_state low; | |||
tap_state_t high; | |||
tap_state_t low; | |||
} tap_transition_t; | |||
extern int tap_move_map[16]; /* map 16 TAP states to 6 stable states */ | |||
extern u8 tap_move[6][6]; /* value scanned to TMS to move from one of six stable states to another */ | |||
extern tap_transition_t tap_transitions[16]; /* describe the TAP state diagram */ | |||
//extern tap_transition_t tap_transitions[16]; /* describe the TAP state diagram */ | |||
/*-----<Cable Helper API>-------------------------------------------*/ | |||
/* The "Cable Helper API" is what the cable drivers can use to help implement | |||
* their "Cable API". So a Cable Helper API is a set of helper functions used by | |||
* cable drivers, and this is different from a Cable API. A "Cable API" is what | |||
* higher level code used to talk to a cable. | |||
*/ | |||
/** implementation of wrapper function tap_set_state() */ | |||
void tap_set_state_impl(tap_state_t new_state); | |||
extern enum tap_state end_state; /* finish DR scans in dr_end_state */ | |||
extern enum tap_state cur_state; /* current TAP state */ | |||
/** | |||
* Function tap_set_state | |||
* sets the state of a "state follower" which tracks the state of the TAPs connected to the | |||
* cable. The state follower is hopefully always in the same state as the actual | |||
* TAPs in the jtag chain, and will be so if there are no bugs in the tracking logic within that | |||
* cable driver. All the cable drivers call this function to indicate the state they think | |||
* the TAPs attached to their cables are in. Because this function can also log transitions, | |||
* it will be helpful to call this function with every transition that the TAPs being manipulated | |||
* are expected to traverse, not just end points of a multi-step state path. | |||
* @param new_state is the state we think the TAPs are currently in or are about to enter. | |||
*/ | |||
#if defined(_DEBUG_JTAG_IO_) | |||
#define tap_set_state(new_state) \ | |||
do { \ | |||
LOG_DEBUG( "tap_set_state(%s)", tap_state_name(new_state) ); \ | |||
tap_set_state_impl(new_state); \ | |||
} while (0) | |||
#else | |||
static inline void tap_set_state(tap_state_t new_state) | |||
{ | |||
tap_set_state_impl(new_state); | |||
} | |||
extern enum tap_state cmd_queue_end_state; /* finish DR scans in dr_end_state */ | |||
extern enum tap_state cmd_queue_cur_state; /* current TAP state */ | |||
#endif | |||
#define TAP_MOVE(from, to) tap_move[tap_move_map[from]][tap_move_map[to]] | |||
/** | |||
* Function tap_get_state | |||
* gets the state of the "state follower" which tracks the state of the TAPs connected to | |||
* the cable. | |||
* @see tap_set_state | |||
* @return tap_state_t - The state the TAPs are in now. | |||
*/ | |||
tap_state_t tap_get_state(void); | |||
typedef void * error_handler_t; /* Later on we can delete error_handler_t, but keep it for now to make patches more readable */ | |||
/** | |||
* Function tap_set_end_state | |||
* sets the state of an "end state follower" which tracks the state that any cable driver | |||
* thinks will be the end (resultant) state of the current TAP SIR or SDR operation. At completion | |||
* of that TAP operation this value is copied into the state follower via tap_set_state(). | |||
* @param new_end_state is that state the TAPs should enter at completion of a pending TAP operation. | |||
*/ | |||
void tap_set_end_state(tap_state_t new_end_state); | |||
/** | |||
* Function tap_get_end_state | |||
* @see tap_set_end_state | |||
* @return tap_state_t - The state the TAPs should be in at completion of the current TAP operation. | |||
*/ | |||
tap_state_t tap_get_end_state(void); | |||
/** | |||
* Function tap_get_tms_path | |||
* returns a 7 bit long "bit sequence" indicating what has to be done with TMS | |||
* during a sequence of seven TAP clock cycles in order to get from | |||
* state \a "from" to state \a "to". | |||
* @param from is the starting state | |||
* @param to is the resultant or final state | |||
* @return int - a 7 bit sequence, with the first bit in the sequence at bit 0. | |||
*/ | |||
int tap_get_tms_path(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 | |||
* sequence of stable states which are given in this order: <p> | |||
* { TAP_RESET, TAP_IDLE, TAP_DRSHIFT, TAP_DRPAUSE, TAP_IRSHIFT, TAP_IRPAUSE } | |||
* <p> | |||
* This sequence corresponds to look up tables which are used in some of the | |||
* cable drivers. | |||
* @param astate is the stable state to find in the sequence. If a non stable | |||
* state is passed, this may cause the program to output an error message | |||
* and terminate. | |||
* @return int - the array (or sequence) index as described above | |||
*/ | |||
int tap_move_ndx(tap_state_t astate); | |||
/** | |||
* Function tap_is_state_stable | |||
* returns TRUE if the \a astate is stable. | |||
*/ | |||
BOOL tap_is_state_stable(tap_state_t astate); | |||
/** | |||
* Function tap_state_transition | |||
* takes a current TAP state and returns the next state according to the tms value. | |||
* @param current_state is the state of a TAP currently. | |||
* @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); | |||
/** | |||
* Function tap_state_name | |||
* Returns a string suitable for display representing the JTAG tap_state | |||
*/ | |||
const char* tap_state_name(tap_state_t state); | |||
/*-----</Cable Helper API>------------------------------------------*/ | |||
extern tap_state_t cmd_queue_end_state; /* finish DR scans in dr_end_state */ | |||
extern tap_state_t cmd_queue_cur_state; /* current TAP state */ | |||
typedef void* error_handler_t; /* Later on we can delete error_handler_t, but keep it for now to make patches more readable */ | |||
struct scan_field_s; | |||
typedef int (*in_handler_t)(u8 *in_value, void *priv, struct scan_field_s *field); | |||
typedef int (*in_handler_t)(u8* in_value, void* priv, struct scan_field_s* field); | |||
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 */ | |||
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* 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 */ | |||
} scan_field_t; | |||
enum scan_type | |||
{ | |||
enum scan_type { | |||
/* IN: from device to host, OUT: from host to device */ | |||
SCAN_IN = 1, SCAN_OUT = 2, SCAN_IO = 3 | |||
}; | |||
typedef struct scan_command_s | |||
{ | |||
int ir_scan; /* instruction/not data scan */ | |||
int num_fields; /* number of fields in *fields array */ | |||
scan_field_t *fields; /* pointer to an array of data scan fields */ | |||
enum tap_state end_state; /* TAP state in which JTAG commands should finish */ | |||
int ir_scan; /* instruction/not data scan */ | |||
int num_fields; /* number of fields in *fields array */ | |||
scan_field_t* fields; /* pointer to an array of data scan fields */ | |||
tap_state_t end_state; /* TAP state in which JTAG commands should finish */ | |||
} scan_command_t; | |||
typedef struct statemove_command_s | |||
{ | |||
enum tap_state end_state; /* TAP state in which JTAG commands should finish */ | |||
tap_state_t end_state; /* TAP state in which JTAG commands should finish */ | |||
} statemove_command_t; | |||
typedef struct pathmove_command_s | |||
{ | |||
int num_states; /* number of states in *path */ | |||
enum tap_state *path; /* states that have to be passed */ | |||
int num_states; /* number of states in *path */ | |||
tap_state_t* path; /* states that have to be passed */ | |||
} pathmove_command_t; | |||
typedef struct runtest_command_s | |||
{ | |||
int num_cycles; /* number of cycles that should be spent in Run-Test/Idle */ | |||
enum tap_state end_state; /* TAP state in which JTAG commands should finish */ | |||
int num_cycles; /* number of cycles that should be spent in Run-Test/Idle */ | |||
tap_state_t end_state; /* TAP state in which JTAG commands should finish */ | |||
} runtest_command_t; | |||
typedef struct stableclocks_command_s | |||
{ | |||
int num_cycles; /* number of clock cycles that should be sent */ | |||
int num_cycles; /* number of clock cycles that should be sent */ | |||
} stableclocks_command_t; | |||
typedef struct reset_command_s | |||
{ | |||
int trst; /* trst/srst 0: deassert, 1: assert, -1: don't change */ | |||
int trst; /* trst/srst 0: deassert, 1: assert, -1: don't change */ | |||
int srst; | |||
} reset_command_t; | |||
typedef struct end_state_command_s | |||
{ | |||
enum tap_state end_state; /* TAP state in which JTAG commands should finish */ | |||
tap_state_t end_state; /* TAP state in which JTAG commands should finish */ | |||
} end_state_command_t; | |||
typedef struct sleep_command_s | |||
{ | |||
u32 us; /* number of microseconds to sleep */ | |||
u32 us; /* number of microseconds to sleep */ | |||
} sleep_command_t; | |||
typedef union jtag_command_container_u | |||
{ | |||
scan_command_t *scan; | |||
statemove_command_t *statemove; | |||
pathmove_command_t *pathmove; | |||
runtest_command_t *runtest; | |||
stableclocks_command_t *stableclocks; | |||
reset_command_t *reset; | |||
end_state_command_t *end_state; | |||
sleep_command_t *sleep; | |||
scan_command_t* scan; | |||
statemove_command_t* statemove; | |||
pathmove_command_t* pathmove; | |||
runtest_command_t* runtest; | |||
stableclocks_command_t* stableclocks; | |||
reset_command_t* reset; | |||
end_state_command_t* end_state; | |||
sleep_command_t* sleep; | |||
} jtag_command_container_t; | |||
enum jtag_command_type | |||
{ | |||
JTAG_SCAN = 1, | |||
JTAG_STATEMOVE = 2, JTAG_RUNTEST = 3, | |||
JTAG_RESET = 4, JTAG_END_STATE = 5, | |||
JTAG_PATHMOVE = 6, JTAG_SLEEP = 7, | |||
enum jtag_command_type { | |||
JTAG_SCAN = 1, | |||
JTAG_STATEMOVE = 2, | |||
JTAG_RUNTEST = 3, | |||
JTAG_RESET = 4, | |||
JTAG_END_STATE = 5, | |||
JTAG_PATHMOVE = 6, | |||
JTAG_SLEEP = 7, | |||
JTAG_STABLECLOCKS = 8 | |||
}; | |||
typedef struct jtag_command_s | |||
{ | |||
jtag_command_container_t cmd; | |||
enum jtag_command_type type; | |||
struct jtag_command_s *next; | |||
enum jtag_command_type type; | |||
struct jtag_command_s* next; | |||
} jtag_command_t; | |||
extern jtag_command_t *jtag_command_queue; | |||
extern jtag_command_t* jtag_command_queue; | |||
/* forward declaration */ | |||
typedef struct jtag_tap_event_action_s jtag_tap_event_action_t; | |||
@@ -179,59 +291,66 @@ typedef struct jtag_tap_event_action_s jtag_tap_event_action_t; | |||
/* due to "forward decloration reasons" */ | |||
struct jtag_tap_s | |||
{ | |||
const char *chip; | |||
const char *tapname; | |||
const char *dotted_name; | |||
const char* chip; | |||
const char* tapname; | |||
const char* dotted_name; | |||
int abs_chain_position; | |||
int 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 */ | |||
u32 *expected_ids; /* Array of expected identification codes */ | |||
u8 expected_ids_cnt;/* Number of expected identification codes */ | |||
u8 *cur_instr; /* current instruction */ | |||
int bypass; /* bypass register selected */ | |||
jtag_tap_event_action_t *event_action; | |||
jtag_tap_t *next_tap; | |||
int 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 */ | |||
u32* expected_ids; /* Array of expected identification codes */ | |||
u8 expected_ids_cnt; /* Number of expected identification codes */ | |||
u8* cur_instr; /* current instruction */ | |||
int bypass; /* bypass register selected */ | |||
jtag_tap_event_action_t* event_action; | |||
jtag_tap_t* next_tap; | |||
}; | |||
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); | |||
extern int jtag_NumEnabledTaps(void); | |||
extern int jtag_NumTotalTaps(void); | |||
static __inline__ jtag_tap_t * | |||
jtag_NextEnabledTap( jtag_tap_t *p ) | |||
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); | |||
extern int jtag_NumEnabledTaps(void); | |||
extern int jtag_NumTotalTaps(void); | |||
static __inline__ jtag_tap_t* jtag_NextEnabledTap(jtag_tap_t* p) | |||
{ | |||
if( p == NULL ){ | |||
if (p == NULL) | |||
{ | |||
/* start at the head of list */ | |||
p = jtag_AllTaps(); | |||
} else { | |||
} | |||
else | |||
{ | |||
/* start *after* this one */ | |||
p = p->next_tap; | |||
} | |||
while( p ){ | |||
if( p->enabled ){ | |||
while (p) | |||
{ | |||
if (p->enabled) | |||
{ | |||
break; | |||
} else { | |||
} | |||
else | |||
{ | |||
p = p->next_tap; | |||
} | |||
} | |||
return p; | |||
} | |||
enum reset_line_mode | |||
{ | |||
enum reset_line_mode { | |||
LINE_OPEN_DRAIN = 0x0, | |||
LINE_PUSH_PULL = 0x1, | |||
LINE_PUSH_PULL = 0x1, | |||
}; | |||
typedef struct jtag_interface_s | |||
@@ -245,61 +364,62 @@ typedef struct jtag_interface_s | |||
/* interface initalization | |||
*/ | |||
int (*speed)(int speed); | |||
int (*register_commands)(struct command_context_s *cmd_ctx); | |||
int (*register_commands)(struct command_context_s* cmd_ctx); | |||
int (*init)(void); | |||
int (*quit)(void); | |||
/* returns JTAG maxium speed for KHz. 0=RTCK. The function returns | |||
a failure if it can't support the KHz/RTCK. | |||
WARNING!!!! if RTCK is *slow* then think carefully about | |||
whether you actually want to support this in the driver. | |||
Many target scripts are written to handle the absence of RTCK | |||
and use a fallback kHz TCK. | |||
*/ | |||
int (*khz)(int khz, int *jtag_speed); | |||
* a failure if it can't support the KHz/RTCK. | |||
* | |||
* WARNING!!!! if RTCK is *slow* then think carefully about | |||
* whether you actually want to support this in the driver. | |||
* Many target scripts are written to handle the absence of RTCK | |||
* and use a fallback kHz TCK. | |||
*/ | |||
int (*khz)(int khz, int* jtag_speed); | |||
/* returns the KHz for the provided JTAG speed. 0=RTCK. The function returns | |||
a failure if it can't support the KHz/RTCK. */ | |||
int (*speed_div)(int speed, int *khz); | |||
* a failure if it can't support the KHz/RTCK. */ | |||
int (*speed_div)(int speed, int* khz); | |||
/* Read and clear the power dropout flag. Note that a power dropout | |||
can be transitionary, easily much less than a ms. | |||
So to find out if the power is *currently* on, you must invoke | |||
this method twice. Once to clear the power dropout flag and a | |||
second time to read the current state. | |||
* can be transitionary, easily much less than a ms. | |||
* | |||
* So to find out if the power is *currently* on, you must invoke | |||
* this method twice. Once to clear the power dropout flag and a | |||
* second time to read the current state. | |||
* | |||
* Currently the default implementation is never to detect power dropout. | |||
*/ | |||
int (*power_dropout)(int* power_dropout); | |||
Currently the default implementation is never to detect power dropout. | |||
*/ | |||
int (*power_dropout)(int *power_dropout); | |||
/* Read and clear the srst asserted detection flag. | |||
* | |||
* NB!!!! like power_dropout this does *not* read the current | |||
* state. srst assertion is transitionary and *can* be much | |||
* less than 1ms. | |||
*/ | |||
int (*srst_asserted)(int *srst_asserted); | |||
int (*srst_asserted)(int* srst_asserted); | |||
} jtag_interface_t; | |||
enum jtag_event | |||
{ | |||
enum jtag_event { | |||
JTAG_TRST_ASSERTED | |||
}; | |||
extern char * jtag_event_strings[]; | |||
extern char* jtag_event_strings[]; | |||
enum jtag_tap_event | |||
{ | |||
enum jtag_tap_event { | |||
JTAG_TAP_EVENT_ENABLE, | |||
JTAG_TAP_EVENT_DISABLE | |||
}; | |||
extern const Jim_Nvp nvp_jtag_tap_event[]; | |||
struct jtag_tap_event_action_s { | |||
enum jtag_tap_event event; | |||
Jim_Obj *body; | |||
jtag_tap_event_action_t *next; | |||
struct jtag_tap_event_action_s | |||
{ | |||
enum jtag_tap_event event; | |||
Jim_Obj* body; | |||
jtag_tap_event_action_t* next; | |||
}; | |||
extern int jtag_trst; | |||
@@ -307,30 +427,27 @@ extern int jtag_srst; | |||
typedef struct jtag_event_callback_s | |||
{ | |||
int (*callback)(enum jtag_event event, void *priv); | |||
void *priv; | |||
struct jtag_event_callback_s *next; | |||
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; | |||
extern jtag_event_callback_t* jtag_event_callbacks; | |||
extern jtag_interface_t *jtag; /* global pointer to configured JTAG interface */ | |||
extern enum tap_state end_state; | |||
extern enum tap_state cur_state; | |||
extern jtag_interface_t* jtag; /* global pointer to configured JTAG interface */ | |||
extern int jtag_speed; | |||
extern int jtag_speed_post_reset; | |||
enum reset_types | |||
{ | |||
RESET_NONE = 0x0, | |||
RESET_HAS_TRST = 0x1, | |||
RESET_HAS_SRST = 0x2, | |||
RESET_TRST_AND_SRST = 0x3, | |||
enum reset_types { | |||
RESET_NONE = 0x0, | |||
RESET_HAS_TRST = 0x1, | |||
RESET_HAS_SRST = 0x2, | |||
RESET_TRST_AND_SRST = 0x3, | |||
RESET_SRST_PULLS_TRST = 0x4, | |||
RESET_TRST_PULLS_SRST = 0x8, | |||
RESET_TRST_OPEN_DRAIN = 0x10, | |||
RESET_SRST_PUSH_PULL = 0x20, | |||
RESET_SRST_PUSH_PULL = 0x20, | |||
}; | |||
extern enum reset_types jtag_reset_config; | |||
@@ -338,14 +455,16 @@ extern enum reset_types jtag_reset_config; | |||
/* initialize interface upon startup. A successful no-op | |||
* upon subsequent invocations | |||
*/ | |||
extern int jtag_interface_init(struct command_context_s *cmd_ctx); | |||
extern int jtag_interface_init(struct command_context_s* cmd_ctx); | |||
/* initialize JTAG chain using only a RESET reset. If init fails, | |||
* try reset + init. | |||
*/ | |||
extern int jtag_init(struct command_context_s *cmd_ctx); | |||
extern int jtag_init(struct command_context_s* 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); | |||
extern int jtag_init_reset(struct command_context_s* cmd_ctx); | |||
extern int jtag_register_commands(struct command_context_s* cmd_ctx); | |||
/* JTAG interface, can be implemented with a software or hardware fifo | |||
* | |||
@@ -359,19 +478,21 @@ extern int jtag_register_commands(struct command_context_s *cmd_ctx); | |||
* be issued. | |||
* | |||
*/ | |||
extern void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); | |||
extern int interface_jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); | |||
extern void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); | |||
extern int interface_jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); | |||
extern void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); | |||
extern int interface_jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); | |||
extern void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); | |||
extern int interface_jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); | |||
extern void jtag_add_ir_scan(int num_fields, scan_field_t* fields, tap_state_t endstate); | |||
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); | |||
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); | |||
/* 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); | |||
extern int interface_jtag_add_tlr(void); | |||
/* Do not use jtag_add_pathmove() unless you need to, but do use it | |||
* if you have to. | |||
* | |||
@@ -402,8 +523,9 @@ extern int interface_jtag_add_tlr(void); | |||
* a partial implementation of pathmove would have little practical | |||
* application. | |||
*/ | |||
extern void jtag_add_pathmove(int num_states, enum tap_state *path); | |||
extern int interface_jtag_add_pathmove(int num_states, enum tap_state *path); | |||
extern void jtag_add_pathmove(int num_states, tap_state_t* path); | |||
extern int interface_jtag_add_pathmove(int num_states, tap_state_t* path); | |||
/* go to TAP_IDLE, if we're not already there and cycle | |||
* precisely num_cycles in the TAP_IDLE after which move | |||
* to the end state, if it is != TAP_IDLE | |||
@@ -411,8 +533,9 @@ extern int interface_jtag_add_pathmove(int num_states, enum tap_state *path); | |||
* nb! num_cycles can be 0, in which case the fn will navigate | |||
* to endstate via TAP_IDLE | |||
*/ | |||
extern void jtag_add_runtest(int num_cycles, enum tap_state endstate); | |||
extern int interface_jtag_add_runtest(int num_cycles, enum tap_state endstate); | |||
extern void jtag_add_runtest(int num_cycles, tap_state_t endstate); | |||
extern int interface_jtag_add_runtest(int num_cycles, tap_state_t endstate); | |||
/* A reset of the TAP state machine can be requested. | |||
* | |||
* Whether tms or trst reset is used depends on the capabilities of | |||
@@ -436,6 +559,7 @@ extern int interface_jtag_add_runtest(int num_cycles, enum tap_state endstate); | |||
* then trst & srst *must* be asserted together. | |||
*/ | |||
extern void jtag_add_reset(int req_tlr_or_trst, int srst); | |||
/* this drives the actual srst and trst pins. srst will always be 0 | |||
* if jtag_reset_config & RESET_SRST_PULLS_TRST != 0 and ditto for | |||
* trst. | |||
@@ -443,11 +567,11 @@ extern void jtag_add_reset(int req_tlr_or_trst, int srst); | |||
* the higher level jtag_add_reset will invoke jtag_add_tlr() if | |||
* approperiate | |||
*/ | |||
extern int interface_jtag_add_reset(int trst, int srst); | |||
extern void jtag_add_end_state(enum tap_state endstate); | |||
extern int interface_jtag_add_end_state(enum tap_state endstate); | |||
extern int interface_jtag_add_reset(int trst, int srst); | |||
extern void jtag_add_end_state(tap_state_t endstate); | |||
extern int interface_jtag_add_end_state(tap_state_t endstate); | |||
extern void jtag_add_sleep(u32 us); | |||
extern int interface_jtag_add_sleep(u32 us); | |||
extern int interface_jtag_add_sleep(u32 us); | |||
/** | |||
@@ -455,8 +579,8 @@ extern int interface_jtag_add_sleep(u32 us); | |||
* first checks that the state in which the clocks are to be issued is | |||
* stable, then queues up clock_count clocks for transmission. | |||
*/ | |||
void jtag_add_clocks( int num_cycles ); | |||
int interface_jtag_add_clocks( int num_cycles ); | |||
void jtag_add_clocks(int num_cycles); | |||
int interface_jtag_add_clocks(int num_cycles); | |||
/* | |||
@@ -479,37 +603,38 @@ int interface_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); | |||
extern int jtag_execute_queue(void); | |||
/* 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); | |||
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); | |||
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); | |||
extern int jtag_build_buffer(scan_command_t *cmd, u8 **buffer); | |||
extern void jtag_set_check_value(scan_field_t* field, u8* value, u8* mask, error_handler_t* in_error_handler); | |||
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); | |||
extern int jtag_build_buffer(scan_command_t* cmd, u8** buffer); | |||
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 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_tap_handle_event(jtag_tap_t* tap, enum jtag_tap_event e); | |||
/* error codes | |||
* JTAG subsystem uses codes between -100 and -199 */ | |||
#define ERROR_JTAG_INIT_FAILED (-100) | |||
#define ERROR_JTAG_INVALID_INTERFACE (-101) | |||
#define ERROR_JTAG_NOT_IMPLEMENTED (-102) | |||
#define ERROR_JTAG_TRST_ASSERTED (-103) | |||
#define ERROR_JTAG_QUEUE_FAILED (-104) | |||
#define ERROR_JTAG_NOT_STABLE_STATE (-105) | |||
#define ERROR_JTAG_DEVICE_ERROR (-107) | |||
#define ERROR_JTAG_INIT_FAILED (-100) | |||
#define ERROR_JTAG_INVALID_INTERFACE (-101) | |||
#define ERROR_JTAG_NOT_IMPLEMENTED (-102) | |||
#define ERROR_JTAG_TRST_ASSERTED (-103) | |||
#define ERROR_JTAG_QUEUE_FAILED (-104) | |||
#define ERROR_JTAG_NOT_STABLE_STATE (-105) | |||
#define ERROR_JTAG_DEVICE_ERROR (-107) | |||
/* this allows JTAG devices to implement the entire jtag_xxx() layer in hw/sw */ | |||
@@ -519,6 +644,7 @@ void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e); | |||
#define MINIDRIVER(a) notused ## a | |||
#else | |||
#define MINIDRIVER(a) a | |||
/* 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 | |||
@@ -536,30 +662,19 @@ void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e); | |||
* | |||
* Note that this jtag_add_dr_out can be defined as an inline function. | |||
*/ | |||
extern void interface_jtag_add_dr_out(jtag_tap_t *tap, | |||
int num_fields, | |||
const int *num_bits, | |||
const u32 *value, | |||
enum tap_state end_state); | |||
extern void interface_jtag_add_dr_out(jtag_tap_t* tap, int num_fields, const int* num_bits, const u32* value, | |||
tap_state_t end_state); | |||
#endif | |||
static __inline__ void jtag_add_dr_out(jtag_tap_t *tap, | |||
int num_fields, | |||
const int *num_bits, | |||
const u32 *value, | |||
enum tap_state end_state) | |||
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) | |||
cmd_queue_end_state=end_state; | |||
cmd_queue_cur_state=cmd_queue_end_state; | |||
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); | |||
} | |||
/** | |||
* Function jtag_state_name | |||
* Returns a string suitable for display representing the JTAG tap_state | |||
*/ | |||
const char* jtag_state_name(enum tap_state state); | |||
#endif /* JTAG_H */ |
@@ -122,7 +122,7 @@ ep1_generic_commandl( | |||
*usb_buffer_p++ = va_arg(ap, int); | |||
length--; | |||
} | |||
memset( | |||
usb_buffer_p, | |||
0, | |||
@@ -176,7 +176,7 @@ ep1_memory_read( | |||
usb_buffer[2] = addr; | |||
usb_buffer[3] = length; | |||
usb_ret = usb_bulk_write( | |||
usb_ret = usb_bulk_write( | |||
pHDev, USB_EP1OUT_ADDR, | |||
usb_buffer, sizeof(usb_buffer), | |||
USB_TIMEOUT_MS | |||
@@ -185,7 +185,7 @@ ep1_memory_read( | |||
if(usb_ret < sizeof(usb_buffer)) { | |||
break; | |||
} | |||
usb_ret = usb_bulk_read( | |||
pHDev, USB_EP1IN_ADDR, | |||
buffer, length, | |||
@@ -195,7 +195,7 @@ ep1_memory_read( | |||
if(usb_ret < length) { | |||
break; | |||
} | |||
addr += length; | |||
buffer += length; | |||
count += length; | |||
@@ -247,7 +247,7 @@ ep1_memory_write( | |||
sizeof(usb_buffer) - 4 - length | |||
); | |||
usb_ret = usb_bulk_write( | |||
usb_ret = usb_bulk_write( | |||
pHDev, USB_EP1OUT_ADDR, | |||
(char *)usb_buffer, sizeof(usb_buffer), | |||
USB_TIMEOUT_MS | |||
@@ -256,7 +256,7 @@ ep1_memory_write( | |||
if(usb_ret < sizeof(usb_buffer)) { | |||
break; | |||
} | |||
addr += length; | |||
buffer += length; | |||
count += length; | |||
@@ -343,7 +343,7 @@ dtc_load_from_buffer( | |||
LOG_ERROR("Malformed DTC image\n"); | |||
exit(1); | |||
} | |||
header = (struct header_s *)buffer; | |||
buffer += sizeof(*header); | |||
length -= sizeof(*header); | |||
@@ -352,7 +352,7 @@ dtc_load_from_buffer( | |||
LOG_ERROR("Malformed DTC image\n"); | |||
exit(1); | |||
} | |||
switch(header->type) { | |||
case DTCLOAD_COMMENT: | |||
break; | |||
@@ -365,7 +365,7 @@ dtc_load_from_buffer( | |||
break; | |||
case DTCLOAD_LOAD: | |||
/* Send the DTC program to ST7 RAM. */ | |||
/* Send the DTC program to ST7 RAM. */ | |||
usb_err = ep1_memory_write( | |||
pHDev, | |||
DTC_LOAD_BUFFER, | |||
@@ -398,9 +398,9 @@ dtc_load_from_buffer( | |||
case DTCLOAD_LUT_START: | |||
lut_start = buffer[0]; | |||
break; | |||
case DTCLOAD_LUT: | |||
usb_err = ep1_memory_write( | |||
usb_err = ep1_memory_write( | |||
pHDev, | |||
ST7_USB_BUF_EP0OUT + lut_start, | |||
header->length + 1, buffer | |||
@@ -413,7 +413,7 @@ dtc_load_from_buffer( | |||
exit(1); | |||
break; | |||
} | |||
buffer += (header->length + 1); | |||
length -= (header->length + 1); | |||
} | |||
@@ -434,7 +434,7 @@ dtc_start_download(void) { | |||
/* set up for download mode and make sure EP2 is set up to transmit */ | |||
usb_err = ep1_generic_commandl( | |||
pHDev, 7, | |||
EP1_CMD_DTC_STOP, | |||
EP1_CMD_SET_UPLOAD, | |||
EP1_CMD_SET_DOWNLOAD, | |||
@@ -455,7 +455,7 @@ dtc_start_download(void) { | |||
usb_err = ep1_generic_commandl( | |||
pHDev, 13, | |||
EP1_CMD_MEMORY_WRITE, /* preinitialize poll byte */ | |||
DTC_STATUS_POLL_BYTE >> 8, | |||
DTC_STATUS_POLL_BYTE, | |||
@@ -682,7 +682,7 @@ dtc_queue_run(void) { | |||
usb_err = dtc_run_download(pHDev, | |||
dtc_queue.cmd_buffer, dtc_queue.cmd_index, | |||
NULL, 0 | |||
); | |||
); | |||
if(usb_err < 0) { | |||
LOG_ERROR("dtc_run_download: %s\n", usb_strerror()); | |||
exit(1); | |||
@@ -691,7 +691,7 @@ dtc_queue_run(void) { | |||
usb_err = dtc_run_download(pHDev, | |||
dtc_queue.cmd_buffer, dtc_queue.cmd_index, | |||
reply_buffer, dtc_queue.reply_index | |||
); | |||
); | |||
if(usb_err < 0) { | |||
LOG_ERROR("dtc_run_download: %s\n", usb_strerror()); | |||
exit(1); | |||
@@ -726,7 +726,7 @@ dtc_queue_run(void) { | |||
} else { | |||
*tdo_p &=~ tdo_mask; | |||
} | |||
dtc_mask >>= 1; | |||
if(dtc_mask == 0) { | |||
dtc_p++; | |||
@@ -772,7 +772,7 @@ dtc_queue_run(void) { | |||
tdo_p++; | |||
tdo_mask = 1; | |||
} | |||
} | |||
} | |||
@@ -825,7 +825,7 @@ tap_state_queue_run(void) { | |||
bits = 1; | |||
byte = 0; | |||
for(i = tap_state_queue.length; i--;) { | |||
byte <<= 1; | |||
if(tap_state_queue.buffer & 1) { | |||
byte |= 1; | |||
@@ -890,10 +890,10 @@ tap_state_queue_append( | |||
static | |||
void rlink_end_state(enum tap_state state) | |||
void rlink_end_state(tap_state_t state) | |||
{ | |||
if (tap_move_map[state] != -1) | |||
end_state = state; | |||
if (tap_is_state_stable(state)) | |||
tap_set_end_state(state); | |||
else | |||
{ | |||
LOG_ERROR("BUG: %i is not a valid end state", state); | |||
@@ -906,7 +906,7 @@ static | |||
void rlink_state_move(void) { | |||
int i=0, tms=0; | |||
u8 tms_scan = TAP_MOVE(cur_state, end_state); | |||
u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); | |||
for (i = 0; i < 7; i++) | |||
{ | |||
@@ -914,7 +914,7 @@ void rlink_state_move(void) { | |||
tap_state_queue_append(tms); | |||
} | |||
cur_state = end_state; | |||
tap_set_state(tap_get_end_state()); | |||
} | |||
static | |||
@@ -927,28 +927,28 @@ void rlink_path_move(pathmove_command_t *cmd) | |||
state_count = 0; | |||
while (num_states) | |||
{ | |||
if (tap_transitions[cur_state].low == cmd->path[state_count]) | |||
if (tap_state_transition(tap_get_state(), FALSE) == cmd->path[state_count]) | |||
{ | |||
tms = 0; | |||
} | |||
else if (tap_transitions[cur_state].high == cmd->path[state_count]) | |||
else if (tap_state_transition(tap_get_state(), TRUE) == cmd->path[state_count]) | |||
{ | |||
tms = 1; | |||
} | |||
else | |||
{ | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(cmd->path[state_count])); | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count])); | |||
exit(-1); | |||
} | |||
tap_state_queue_append(tms); | |||
cur_state = cmd->path[state_count]; | |||
tap_set_state(cmd->path[state_count]); | |||
state_count++; | |||
num_states--; | |||
} | |||
end_state = cur_state; | |||
tap_set_end_state(tap_get_state()); | |||
} | |||
@@ -957,10 +957,10 @@ void rlink_runtest(int num_cycles) | |||
{ | |||
int i; | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
/* only do a state_move when we're not already in RTI */ | |||
if (cur_state != TAP_IDLE) | |||
if (tap_get_state() != TAP_IDLE) | |||
{ | |||
rlink_end_state(TAP_IDLE); | |||
rlink_state_move(); | |||
@@ -974,7 +974,7 @@ void rlink_runtest(int num_cycles) | |||
/* finish in end_state */ | |||
rlink_end_state(saved_end_state); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
rlink_state_move(); | |||
} | |||
@@ -997,7 +997,7 @@ void rlink_reset(int trst, int srst) | |||
usb_err = ep1_generic_commandl( | |||
pHDev, 6, | |||
EP1_CMD_MEMORY_WRITE, | |||
ST7_PADR >> 8, | |||
ST7_PADR, | |||
@@ -1031,7 +1031,7 @@ rlink_scan( | |||
int scan_size | |||
) { | |||
int ir_scan; | |||
enum tap_state saved_end_state; | |||
tap_state_t saved_end_state; | |||
int byte_bits; | |||
int extra_bits; | |||
int chunk_bits; | |||
@@ -1051,11 +1051,11 @@ rlink_scan( | |||
/* Move to the proper state before starting to shift TDI/TDO. */ | |||
if (!( | |||
(!ir_scan && (cur_state == TAP_DRSHIFT)) | |||
(!ir_scan && (tap_get_state() == TAP_DRSHIFT)) | |||
|| | |||
(ir_scan && (cur_state == TAP_IRSHIFT)) | |||
(ir_scan && (tap_get_state() == TAP_IRSHIFT)) | |||
)) { | |||
saved_end_state = end_state; | |||
saved_end_state = tap_get_end_state(); | |||
rlink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT); | |||
rlink_state_move(); | |||
rlink_end_state(saved_end_state); | |||
@@ -1102,7 +1102,7 @@ rlink_scan( | |||
x = 0; | |||
dtc_mask = 1 << (extra_bits - 1); | |||
while(extra_bits--) { | |||
if(*tdi_p & tdi_mask) { | |||
x |= dtc_mask; | |||
@@ -1170,7 +1170,7 @@ rlink_scan( | |||
LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno)); | |||
exit(1); | |||
} | |||
tdi_bit_offset += chunk_bits; | |||
} | |||
@@ -1193,12 +1193,12 @@ rlink_scan( | |||
if(type != SCAN_IN) { | |||
x = 0; | |||
dtc_mask = 1 << (8 - 1); | |||
while(chunk_bits--) { | |||
if(*tdi_p & tdi_mask) { | |||
x |= dtc_mask; | |||
} | |||
dtc_mask >>= 1; | |||
if(dtc_mask == 0) { | |||
dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x; | |||
@@ -1206,7 +1206,7 @@ rlink_scan( | |||
x = 0; | |||
dtc_mask = 1 << (8 - 1); | |||
} | |||
tdi_mask <<= 1; | |||
if(tdi_mask == 0) { | |||
tdi_p++; | |||
@@ -1235,7 +1235,7 @@ rlink_scan( | |||
LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno)); | |||
exit(1); | |||
} | |||
tdi_bit_offset += extra_bits; | |||
if(type == SCAN_IN) { | |||
@@ -1248,14 +1248,14 @@ rlink_scan( | |||
x = 0; | |||
dtc_mask = 1 << (8 - 1); | |||
while(extra_bits--) { | |||
if(*tdi_p & tdi_mask) { | |||
x |= dtc_mask; | |||
} | |||
dtc_mask >>= 1; | |||
tdi_mask <<= 1; | |||
if(tdi_mask == 0) { | |||
tdi_p++; | |||
@@ -1293,8 +1293,8 @@ rlink_scan( | |||
LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno)); | |||
exit(1); | |||
} | |||
dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = | |||
dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = | |||
DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 1); | |||
dtc_queue.reply_index++; | |||
@@ -1303,8 +1303,8 @@ rlink_scan( | |||
/* Move to pause state */ | |||
tap_state_queue_append(0); | |||
cur_state = ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE; | |||
if (cur_state != end_state) rlink_state_move(); | |||
tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE); | |||
if (tap_get_state() != tap_get_end_state()) rlink_state_move(); | |||
return(0); | |||
} | |||
@@ -1363,7 +1363,7 @@ int rlink_execute_queue(void) | |||
#endif | |||
if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST))) | |||
{ | |||
cur_state = TAP_RESET; | |||
tap_set_state(TAP_RESET); | |||
} | |||
rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
break; | |||
@@ -1451,7 +1451,7 @@ int rlink_speed(int speed) | |||
LOG_ERROR("An error occurred while trying to load DTC code for speed \"%d\".\n", speed); | |||
exit(1); | |||
} | |||
if(dtc_start_download() < 0) { | |||
LOG_ERROR("%s, %d: starting DTC: %s", | |||
__FILE__, __LINE__, | |||
@@ -1605,7 +1605,7 @@ int rlink_init(void) | |||
/* usb_set_configuration required under win32 */ | |||
usb_set_configuration(pHDev, dev->config[0].bConfigurationValue); | |||
retries = 3; | |||
do | |||
{ | |||
@@ -58,7 +58,7 @@ int usbprog_register_commands(struct command_context_s *cmd_ctx); | |||
int usbprog_init(void); | |||
int usbprog_quit(void); | |||
void usbprog_end_state(enum tap_state state); | |||
void usbprog_end_state(tap_state_t state); | |||
void usbprog_state_move(void); | |||
void usbprog_path_move(pathmove_command_t *cmd); | |||
void usbprog_runtest(int num_cycles); | |||
@@ -151,7 +151,7 @@ int usbprog_execute_queue(void) | |||
#endif | |||
if (cmd->cmd.reset->trst == 1) | |||
{ | |||
cur_state = TAP_RESET; | |||
tap_set_state(TAP_RESET); | |||
} | |||
usbprog_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
break; | |||
@@ -235,10 +235,10 @@ int usbprog_quit(void) | |||
} | |||
/*************** jtag execute commands **********************/ | |||
void usbprog_end_state(enum tap_state state) | |||
void usbprog_end_state(tap_state_t state) | |||
{ | |||
if (tap_move_map[state] != -1) | |||
end_state = state; | |||
if (tap_is_state_stable(state)) | |||
tap_set_end_state(state); | |||
else | |||
{ | |||
LOG_ERROR("BUG: %i is not a valid end state", state); | |||
@@ -249,7 +249,7 @@ void usbprog_end_state(enum tap_state state) | |||
void usbprog_state_move(void) | |||
{ | |||
int i = 0, tms = 0; | |||
u8 tms_scan = TAP_MOVE(cur_state, end_state); | |||
u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); | |||
usbprog_jtag_write_tms(usbprog_jtag_handle, (char)tms_scan); | |||
for (i = 0; i < 7; i++) | |||
@@ -257,7 +257,7 @@ void usbprog_state_move(void) | |||
tms = (tms_scan >> i) & 1; | |||
} | |||
cur_state = end_state; | |||
tap_set_state(tap_get_end_state()); | |||
} | |||
void usbprog_path_move(pathmove_command_t *cmd) | |||
@@ -268,13 +268,13 @@ void usbprog_path_move(pathmove_command_t *cmd) | |||
state_count = 0; | |||
while (num_states) | |||
{ | |||
if (tap_transitions[cur_state].low == cmd->path[state_count]) | |||
if (tap_state_transition(tap_get_state(), FALSE) == cmd->path[state_count]) | |||
{ | |||
/* LOG_INFO("1"); */ | |||
usbprog_write(0, 0, 0); | |||
usbprog_write(1, 0, 0); | |||
} | |||
else if (tap_transitions[cur_state].high == cmd->path[state_count]) | |||
else if (tap_state_transition(tap_get_state(), TRUE) == cmd->path[state_count]) | |||
{ | |||
/* LOG_INFO("2"); */ | |||
usbprog_write(0, 1, 0); | |||
@@ -282,16 +282,16 @@ void usbprog_path_move(pathmove_command_t *cmd) | |||
} | |||
else | |||
{ | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(cmd->path[state_count])); | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count])); | |||
exit(-1); | |||
} | |||
cur_state = cmd->path[state_count]; | |||
tap_set_state(cmd->path[state_count]); | |||
state_count++; | |||
num_states--; | |||
} | |||
end_state = cur_state; | |||
tap_set_end_state(tap_get_state()); | |||
} | |||
void usbprog_runtest(int num_cycles) | |||
@@ -299,7 +299,7 @@ void usbprog_runtest(int num_cycles) | |||
int i; | |||
/* only do a state_move when we're not already in IDLE */ | |||
if (cur_state != TAP_IDLE) | |||
if (tap_get_state() != TAP_IDLE) | |||
{ | |||
usbprog_end_state(TAP_IDLE); | |||
usbprog_state_move(); | |||
@@ -326,14 +326,14 @@ void usbprog_runtest(int num_cycles) | |||
/* finish in end_state */ | |||
/* | |||
usbprog_end_state(saved_end_state); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
usbprog_state_move(); | |||
*/ | |||
} | |||
void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) | |||
{ | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
if (ir_scan) | |||
usbprog_end_state(TAP_IRSHIFT); | |||
@@ -361,11 +361,11 @@ void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) | |||
} | |||
if (ir_scan) | |||
cur_state = TAP_IRPAUSE; | |||
tap_set_state(TAP_IRPAUSE); | |||
else | |||
cur_state = TAP_DRPAUSE; | |||
tap_set_state(TAP_DRPAUSE); | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
usbprog_state_move(); | |||
} | |||
@@ -92,7 +92,7 @@ static u8* vsllink_usb_out_buffer = NULL; | |||
#define JTAG_PINMSK_TDO (1 << 7) | |||
#define VSLLINK_TAP_MOVE(from, to) VSLLINK_tap_move[tap_move_map[from]][tap_move_map[to]] | |||
#define VSLLINK_TAP_MOVE(from, to) VSLLINK_tap_move[tap_move_ndx(from)][tap_move_ndx(to)] | |||
/* VSLLINK_tap_move[i][j]: tap movement command to go from state i to state j | |||
* 0: Test-Logic-Reset | |||
@@ -101,7 +101,7 @@ static u8* vsllink_usb_out_buffer = NULL; | |||
* 3: Pause-DR | |||
* 4: Shift-IR | |||
* 5: Pause-IR | |||
* | |||
* | |||
* SD->SD and SI->SI have to be caught in interface specific code | |||
*/ | |||
u8 VSLLINK_tap_move[6][6] = | |||
@@ -202,9 +202,9 @@ int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *c | |||
int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); | |||
/* Queue command functions */ | |||
void vsllink_end_state(enum tap_state state); | |||
void vsllink_end_state(tap_state_t state); | |||
void vsllink_state_move(void); | |||
void vsllink_path_move(int num_states, enum tap_state *path); | |||
void vsllink_path_move(int num_states, tap_state_t *path); | |||
void vsllink_runtest(int num_cycles); | |||
void vsllink_stableclocks(int num_cycles, int tms); | |||
void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command); | |||
@@ -267,17 +267,17 @@ int vsllink_execute_queue(void) | |||
switch (cmd->type) | |||
{ | |||
case JTAG_END_STATE: | |||
DEBUG_JTAG_IO("end_state: %s", jtag_state_name(cmd->cmd.end_state->end_state)); | |||
DEBUG_JTAG_IO("end_state: %s", tap_state_name(cmd->cmd.end_state->end_state)); | |||
if (cmd->cmd.end_state->end_state != -1) | |||
{ | |||
vsllink_end_state(cmd->cmd.end_state->end_state); | |||
} | |||
break; | |||
case JTAG_RUNTEST: | |||
DEBUG_JTAG_IO( "runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, \ | |||
jtag_state_name(cmd->cmd.runtest->end_state)); | |||
tap_state_name(cmd->cmd.runtest->end_state)); | |||
if (cmd->cmd.runtest->end_state != -1) | |||
{ | |||
@@ -285,39 +285,39 @@ int vsllink_execute_queue(void) | |||
} | |||
vsllink_runtest(cmd->cmd.runtest->num_cycles); | |||
break; | |||
case JTAG_STATEMOVE: | |||
DEBUG_JTAG_IO("statemove end in %s", jtag_state_name(cmd->cmd.statemove->end_state)); | |||
DEBUG_JTAG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state)); | |||
if (cmd->cmd.statemove->end_state != -1) | |||
{ | |||
vsllink_end_state(cmd->cmd.statemove->end_state); | |||
} | |||
vsllink_state_move(); | |||
break; | |||
case JTAG_PATHMOVE: | |||
DEBUG_JTAG_IO("pathmove: %i states, end in %s", \ | |||
cmd->cmd.pathmove->num_states, \ | |||
jtag_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1])); | |||
tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1])); | |||
vsllink_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path); | |||
break; | |||
case JTAG_SCAN: | |||
if (cmd->cmd.scan->end_state != -1) | |||
{ | |||
vsllink_end_state(cmd->cmd.scan->end_state); | |||
} | |||
scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); | |||
if (cmd->cmd.scan->ir_scan) | |||
{ | |||
DEBUG_JTAG_IO("JTAG Scan write IR(%d bits), end in %s:", scan_size, jtag_state_name(cmd->cmd.scan->end_state)); | |||
DEBUG_JTAG_IO("JTAG Scan write IR(%d bits), end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state)); | |||
} | |||
else | |||
{ | |||
DEBUG_JTAG_IO("JTAG Scan write DR(%d bits), end in %s:", scan_size, jtag_state_name(cmd->cmd.scan->end_state)); | |||
DEBUG_JTAG_IO("JTAG Scan write DR(%d bits), end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state)); | |||
} | |||
#ifdef _DEBUG_JTAG_IO_ | |||
@@ -328,7 +328,7 @@ int vsllink_execute_queue(void) | |||
vsllink_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size, cmd->cmd.scan); | |||
break; | |||
case JTAG_RESET: | |||
DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
@@ -336,14 +336,14 @@ int vsllink_execute_queue(void) | |||
if (cmd->cmd.reset->trst == 1) | |||
{ | |||
cur_state = TAP_RESET; | |||
tap_set_state(TAP_RESET); | |||
} | |||
vsllink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); | |||
vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD; | |||
vsllink_usb_out_buffer_idx = 3; | |||
break; | |||
case JTAG_SLEEP: | |||
DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us); | |||
vsllink_tap_execute(); | |||
@@ -352,7 +352,7 @@ int vsllink_execute_queue(void) | |||
case JTAG_STABLECLOCKS: | |||
DEBUG_JTAG_IO("add %d clocks", cmd->cmd.stableclocks->num_cycles); | |||
switch(cur_state) | |||
switch(tap_get_state()) | |||
{ | |||
case TAP_RESET: | |||
// tms should be '1' to stay in TAP_RESET mode | |||
@@ -368,7 +368,7 @@ int vsllink_execute_queue(void) | |||
break; /* above stable states are OK */ | |||
default: | |||
LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"", | |||
jtag_state_name(cur_state) ); | |||
tap_state_name(tap_get_state()) ); | |||
exit(-1); | |||
} | |||
vsllink_stableclocks(cmd->cmd.stableclocks->num_cycles, scan_size); | |||
@@ -380,7 +380,7 @@ int vsllink_execute_queue(void) | |||
} | |||
cmd = cmd->next; | |||
} | |||
return vsllink_tap_execute(); | |||
} | |||
@@ -391,9 +391,9 @@ int vsllink_speed(int speed) | |||
vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_SPEED; | |||
vsllink_usb_out_buffer[1] = (speed >> 0) & 0xff; | |||
vsllink_usb_out_buffer[2] = (speed >> 8) & 0xFF; | |||
result = vsllink_usb_write(vsllink_jtag_handle, 3); | |||
if (result == 3) | |||
{ | |||
return ERROR_OK; | |||
@@ -403,14 +403,14 @@ int vsllink_speed(int speed) | |||
LOG_ERROR("VSLLink setting speed failed (%d)", result); | |||
return ERROR_JTAG_DEVICE_ERROR; | |||
} | |||
return ERROR_OK; | |||
} | |||
int vsllink_khz(int khz, int *jtag_speed) | |||
{ | |||
*jtag_speed = khz; | |||
return ERROR_OK; | |||
} | |||
@@ -423,13 +423,13 @@ int vsllink_speed_div(int jtag_speed, int *khz) | |||
int vsllink_register_commands(struct command_context_s *cmd_ctx) | |||
{ | |||
register_command(cmd_ctx, NULL, "vsllink_usb_vid", vsllink_handle_usb_vid_command, | |||
register_command(cmd_ctx, NULL, "vsllink_usb_vid", vsllink_handle_usb_vid_command, | |||
COMMAND_CONFIG, NULL); | |||
register_command(cmd_ctx, NULL, "vsllink_usb_pid", vsllink_handle_usb_pid_command, | |||
register_command(cmd_ctx, NULL, "vsllink_usb_pid", vsllink_handle_usb_pid_command, | |||
COMMAND_CONFIG, NULL); | |||
register_command(cmd_ctx, NULL, "vsllink_usb_bulkin", vsllink_handle_usb_bulkin_command, | |||
register_command(cmd_ctx, NULL, "vsllink_usb_bulkin", vsllink_handle_usb_bulkin_command, | |||
COMMAND_CONFIG, NULL); | |||
register_command(cmd_ctx, NULL, "vsllink_usb_bulkout", vsllink_handle_usb_bulkout_command, | |||
register_command(cmd_ctx, NULL, "vsllink_usb_bulkout", vsllink_handle_usb_bulkout_command, | |||
COMMAND_CONFIG, NULL); | |||
return ERROR_OK; | |||
@@ -437,7 +437,7 @@ int vsllink_register_commands(struct command_context_s *cmd_ctx) | |||
int vsllink_init(void) | |||
{ | |||
int check_cnt; | |||
int check_cnt; | |||
int result; | |||
char version_str[100]; | |||
@@ -450,13 +450,13 @@ int vsllink_init(void) | |||
} | |||
vsllink_jtag_handle = vsllink_usb_open(); | |||
if (vsllink_jtag_handle == 0) | |||
{ | |||
LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions."); | |||
return ERROR_JTAG_INIT_FAILED; | |||
} | |||
check_cnt = 0; | |||
while (check_cnt < 3) | |||
{ | |||
@@ -517,7 +517,7 @@ int vsllink_init(void) | |||
LOG_INFO("VSLLink JTAG Interface ready"); | |||
vsllink_tap_init(); | |||
return ERROR_OK; | |||
} | |||
@@ -555,10 +555,11 @@ int vsllink_quit(void) | |||
// length of VSLLINK_CMDJTAGSEQ_TMSBYTE has been set, no need to set it here. | |||
void vsllink_append_tms(void) | |||
{ | |||
u8 tms_scan = VSLLINK_TAP_MOVE(cur_state, end_state); | |||
u8 tms_scan = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state()); | |||
u16 tms2; | |||
tap_state_t end_state = tap_get_end_state(); | |||
if (((cur_state != TAP_RESET) && (cur_state != TAP_IDLE) && (cur_state != TAP_DRPAUSE) && (cur_state != TAP_IRPAUSE)) || \ | |||
if (((tap_get_state() != TAP_RESET) && (tap_get_state() != TAP_IDLE) && (tap_get_state() != TAP_DRPAUSE) && (tap_get_state() != TAP_IRPAUSE)) || \ | |||
(vsllink_tms_data_len <= 0) || (vsllink_tms_data_len >= 8) || \ | |||
(vsllink_tms_cmd_pos == NULL)) | |||
{ | |||
@@ -566,15 +567,15 @@ void vsllink_append_tms(void) | |||
exit(-1); | |||
} | |||
tms2 = (tms_scan & VSLLINK_BIT_MSK[VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_position]) << \ | |||
tms2 = (tms_scan & VSLLINK_BIT_MSK[VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_ndx(tap_get_state())][tap_move_ndx(end_state)].insert_position]) << \ | |||
vsllink_tms_data_len; | |||
if (VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_value == 1) | |||
if (VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_ndx(tap_get_state())][tap_move_ndx(end_state)].insert_value == 1) | |||
{ | |||
tms2 |= VSLLINK_BIT_MSK[8 - vsllink_tms_data_len] << \ | |||
(vsllink_tms_data_len + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_position); | |||
(vsllink_tms_data_len + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_ndx(tap_get_state())][tap_move_ndx(end_state)].insert_position); | |||
} | |||
tms2 |= (tms_scan >> VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_position) << \ | |||
(8 + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_position); | |||
tms2 |= (tms_scan >> VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_ndx(tap_get_state())][tap_move_ndx(end_state)].insert_position) << \ | |||
(8 + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_ndx(tap_get_state())][tap_move_ndx(end_state)].insert_position); | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (tms2 >> 0) & 0xff; | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms2 >> 8) & 0xff; | |||
@@ -586,11 +587,11 @@ void vsllink_append_tms(void) | |||
/***************************************************************************/ | |||
/* Queue command implementations */ | |||
void vsllink_end_state(enum tap_state state) | |||
void vsllink_end_state(tap_state_t state) | |||
{ | |||
if (tap_move_map[state] != -1) | |||
if (tap_is_state_stable(state)) | |||
{ | |||
end_state = state; | |||
tap_set_end_state(state); | |||
} | |||
else | |||
{ | |||
@@ -611,14 +612,14 @@ void vsllink_state_move(void) | |||
vsllink_tap_ensure_space(0, 2); | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE; | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(cur_state, end_state); | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state()); | |||
} | |||
cur_state = end_state; | |||
tap_set_state(tap_get_end_state()); | |||
} | |||
// write tms from current vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] | |||
void vsllink_add_path(int start, int num, enum tap_state *path) | |||
void vsllink_add_path(int start, int num, tap_state_t *path) | |||
{ | |||
int i; | |||
@@ -633,20 +634,20 @@ void vsllink_add_path(int start, int num, enum tap_state *path) | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0; | |||
} | |||
if (path[i - start] == tap_transitions[cur_state].high) | |||
if (path[i - start] == tap_state_transition(tap_get_state(), TRUE)) | |||
{ | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] |= 1 << (i & 7); | |||
} | |||
else if (path[i - start] == tap_transitions[cur_state].low) | |||
else if (path[i - start] == tap_state_transition(tap_get_state(), FALSE)) | |||
{ | |||
// nothing to do | |||
} | |||
else | |||
{ | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(path[i])); | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i])); | |||
exit(-1); | |||
} | |||
cur_state = path[i - start]; | |||
tap_set_state(path[i - start]); | |||
} | |||
if ((i > 0) && ((i & 7) == 0)) | |||
{ | |||
@@ -654,10 +655,10 @@ void vsllink_add_path(int start, int num, enum tap_state *path) | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0; | |||
} | |||
end_state = cur_state; | |||
tap_set_end_state(tap_get_state()); | |||
} | |||
void vsllink_path_move(int num_states, enum tap_state *path) | |||
void vsllink_path_move(int num_states, tap_state_t *path) | |||
{ | |||
int i, tms_len, tms_cmd_pos, path_idx = 0; | |||
@@ -934,9 +935,9 @@ void vsllink_stableclocks(int num_cycles, int tms) | |||
void vsllink_runtest(int num_cycles) | |||
{ | |||
enum tap_state saved_end_state = end_state; | |||
tap_state_t saved_end_state = tap_get_end_state(); | |||
if (cur_state != TAP_IDLE) | |||
if (tap_get_state() != TAP_IDLE) | |||
{ | |||
// enter into IDLE state | |||
vsllink_end_state(TAP_IDLE); | |||
@@ -948,8 +949,8 @@ void vsllink_runtest(int num_cycles) | |||
// post-process | |||
// set end_state | |||
vsllink_end_state(saved_end_state); | |||
cur_state = TAP_IDLE; | |||
if (end_state != TAP_IDLE) | |||
tap_set_state(TAP_IDLE); | |||
if (tap_get_end_state() != TAP_IDLE) | |||
{ | |||
vsllink_state_move(); | |||
} | |||
@@ -957,7 +958,7 @@ void vsllink_runtest(int num_cycles) | |||
void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command) | |||
{ | |||
enum tap_state saved_end_state; | |||
tap_state_t saved_end_state; | |||
u8 bits_left, tms_tmp, tdi_len; | |||
int i; | |||
@@ -972,15 +973,15 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s | |||
LOG_ERROR("Your implementation of VSLLink has not enough buffer"); | |||
exit(-1); | |||
} | |||
saved_end_state = end_state; | |||
saved_end_state = tap_get_end_state(); | |||
/* Move to appropriate scan state */ | |||
vsllink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT); | |||
if (vsllink_tms_data_len > 0) | |||
{ | |||
if (cur_state == end_state) | |||
if (tap_get_state() == tap_get_end_state()) | |||
{ | |||
// already in IRSHIFT or DRSHIFT state | |||
// merge tms data in the last tms shift command into next scan command | |||
@@ -1001,7 +1002,7 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s | |||
} | |||
vsllink_tap_ensure_space(1, tdi_len + 7); | |||
// VSLLINK_CMDJTAGSEQ_SCAN ored by 1 means that tms_before is valid | |||
// VSLLINK_CMDJTAGSEQ_SCAN ored by 1 means that tms_before is valid | |||
// which is merged from the last tms shift command | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN | 1; | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 0) & 0xff; | |||
@@ -1041,7 +1042,7 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN | 1; | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 0) & 0xff; | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1)>> 8) & 0xff; | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(cur_state, end_state); | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state()); | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0; | |||
vsllink_tap_append_scan(scan_size, buffer, command, 8); | |||
@@ -1049,7 +1050,7 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s | |||
vsllink_end_state(saved_end_state); | |||
bits_left = scan_size & 0x07; | |||
cur_state = ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE; | |||
tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE); | |||
if (bits_left > 0) | |||
{ | |||
@@ -1060,16 +1061,16 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 1 << 7; | |||
} | |||
if (cur_state != end_state) | |||
if (tap_get_state() != tap_get_end_state()) | |||
{ | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(cur_state, end_state); | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state()); | |||
} | |||
else | |||
{ | |||
vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0; | |||
} | |||
cur_state = end_state; | |||
tap_set_state(tap_get_end_state()); | |||
} | |||
void vsllink_reset(int trst, int srst) | |||
@@ -1077,7 +1078,7 @@ void vsllink_reset(int trst, int srst) | |||
int result; | |||
LOG_DEBUG("trst: %i, srst: %i", trst, srst); | |||
/* Signals are active low */ | |||
vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORT; | |||
vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST; | |||
@@ -1101,12 +1102,12 @@ void vsllink_reset(int trst, int srst) | |||
void vsllink_simple_command(u8 command) | |||
{ | |||
int result; | |||
DEBUG_JTAG_IO("0x%02x", command); | |||
vsllink_usb_out_buffer[0] = command; | |||
result = vsllink_usb_write(vsllink_jtag_handle, 1); | |||
if (result != 1) | |||
{ | |||
LOG_ERROR("VSLLink command 0x%02x failed (%d)", command, result); | |||
@@ -1116,7 +1117,7 @@ void vsllink_simple_command(u8 command) | |||
int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) | |||
{ | |||
if (argc != 1) { | |||
LOG_ERROR("parameter error, should be one parameter for VID"); | |||
LOG_ERROR("parameter error, should be one parameter for VID"); | |||
return ERROR_OK; | |||
} | |||
@@ -1128,7 +1129,7 @@ int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, char *cmd, | |||
int vsllink_handle_usb_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) | |||
{ | |||
if (argc != 1) { | |||
LOG_ERROR("parameter error, should be one parameter for PID"); | |||
LOG_ERROR("parameter error, should be one parameter for PID"); | |||
return ERROR_OK; | |||
} | |||
@@ -1140,7 +1141,7 @@ int vsllink_handle_usb_pid_command(struct command_context_s *cmd_ctx, char *cmd, | |||
int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) | |||
{ | |||
if (argc != 1) { | |||
LOG_ERROR("parameter error, should be one parameter for BULKIN endpoint"); | |||
LOG_ERROR("parameter error, should be one parameter for BULKIN endpoint"); | |||
return ERROR_OK; | |||
} | |||
@@ -1152,7 +1153,7 @@ int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *c | |||
int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) | |||
{ | |||
if (argc != 1) { | |||
LOG_ERROR("parameter error, should be one parameter for BULKOUT endpoint"); | |||
LOG_ERROR("parameter error, should be one parameter for BULKOUT endpoint"); | |||
return ERROR_OK; | |||
} | |||
@@ -1175,7 +1176,7 @@ void vsllink_tap_ensure_space(int scans, int bytes) | |||
{ | |||
int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length; | |||
int available_bytes = VSLLINK_BufferSize - vsllink_usb_out_buffer_idx; | |||
if (scans > available_scans || bytes > available_bytes) | |||
{ | |||
vsllink_tap_execute(); | |||
@@ -1218,9 +1219,9 @@ int vsllink_tap_execute(void) | |||
if (vsllink_tms_data_len > 0) | |||
{ | |||
if((cur_state != TAP_RESET) && (cur_state != TAP_IDLE) && (cur_state != TAP_IRPAUSE) && (cur_state != TAP_DRPAUSE)) | |||
if((tap_get_state() != TAP_RESET) && (tap_get_state() != TAP_IDLE) && (tap_get_state() != TAP_IRPAUSE) && (tap_get_state() != TAP_DRPAUSE)) | |||
{ | |||
LOG_WARNING("%s is not in RESET or IDLE or PAUSR state", jtag_state_name(cur_state)); | |||
LOG_WARNING("%s is not in RESET or IDLE or PAUSR state", tap_state_name(tap_get_state())); | |||
} | |||
if (vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] & (1 << (vsllink_tms_data_len - 1))) | |||
@@ -1238,7 +1239,7 @@ int vsllink_tap_execute(void) | |||
vsllink_tms_data_len = 0; | |||
} | |||
} | |||
if (vsllink_usb_out_buffer_idx > 3) | |||
{ | |||
if (vsllink_usb_out_buffer[0] == VSLLINK_CMD_HW_JTAGSEQCMD) | |||
@@ -1248,7 +1249,7 @@ int vsllink_tap_execute(void) | |||
} | |||
result = vsllink_usb_message(vsllink_jtag_handle, vsllink_usb_out_buffer_idx, vsllink_usb_in_want_length); | |||
if (result == vsllink_usb_in_want_length) | |||
{ | |||
for (i = 0; i < pending_scan_results_length; i++) | |||
@@ -1264,7 +1265,7 @@ int vsllink_tap_execute(void) | |||
// IRSHIFT or DRSHIFT | |||
buf_set_buf(vsllink_usb_in_buffer, first * 8 + offset, buffer, 0, length); | |||
first += (length + offset + 7) >> 3; | |||
DEBUG_JTAG_IO("JTAG scan read(%d bits):", length); | |||
#ifdef _DEBUG_JTAG_IO_ | |||
vsllink_debug_buffer(buffer, (length + 7) >> 3); | |||
@@ -1290,7 +1291,7 @@ int vsllink_tap_execute(void) | |||
LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d", result, vsllink_usb_in_want_length); | |||
return ERROR_JTAG_QUEUE_FAILED; | |||
} | |||
vsllink_tap_init(); | |||
} | |||
@@ -1308,19 +1309,19 @@ vsllink_jtag_t* vsllink_usb_open(void) | |||
struct usb_bus *busses; | |||
struct usb_bus *bus; | |||
struct usb_device *dev; | |||
vsllink_jtag_t *result; | |||
result = (vsllink_jtag_t*) malloc(sizeof(vsllink_jtag_t)); | |||
usb_init(); | |||
usb_find_busses(); | |||
usb_find_devices(); | |||
busses = usb_get_busses(); | |||
/* find vsllink_jtag device in usb bus */ | |||
for (bus = busses; bus; bus = bus->next) | |||
{ | |||
for (dev = bus->devices; dev; dev = dev->next) | |||
@@ -1328,23 +1329,23 @@ vsllink_jtag_t* vsllink_usb_open(void) | |||
if ((dev->descriptor.idVendor == vsllink_vid) && (dev->descriptor.idProduct == vsllink_pid)) | |||
{ | |||
result->usb_handle = usb_open(dev); | |||
/* usb_set_configuration required under win32 */ | |||
usb_set_configuration(result->usb_handle, dev->config[0].bConfigurationValue); | |||
usb_claim_interface(result->usb_handle, 0); | |||
#if 0 | |||
/* | |||
/* | |||
* This makes problems under Mac OS X. And is not needed | |||
* under Windows. Hopefully this will not break a linux build | |||
*/ | |||
usb_set_altinterface(result->usb_handle, 0); | |||
#endif | |||
#endif | |||
return result; | |||
} | |||
} | |||
} | |||
free(result); | |||
return NULL; | |||
} | |||
@@ -1359,7 +1360,7 @@ void vsllink_usb_close(vsllink_jtag_t *vsllink_jtag) | |||
int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_length) | |||
{ | |||
int result; | |||
result = vsllink_usb_write(vsllink_jtag, out_length); | |||
if (result == out_length) | |||
{ | |||
@@ -1389,18 +1390,18 @@ int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_len | |||
int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length) | |||
{ | |||
int result; | |||
if (out_length > VSLLINK_BufferSize) | |||
{ | |||
LOG_ERROR("vsllink_jtag_write illegal out_length=%d (max=%d)", out_length, VSLLINK_BufferSize); | |||
return -1; | |||
} | |||
result = usb_bulk_write(vsllink_jtag->usb_handle, vsllink_bulkout, \ | |||
(char *)vsllink_usb_out_buffer, out_length, VSLLINK_USB_TIMEOUT); | |||
DEBUG_JTAG_IO("vsllink_usb_write, out_length = %d, result = %d", out_length, result); | |||
#ifdef _DEBUG_USB_COMMS_ | |||
LOG_DEBUG("USB out:"); | |||
vsllink_debug_buffer(vsllink_usb_out_buffer, out_length); | |||
@@ -1420,7 +1421,7 @@ int vsllink_usb_read(vsllink_jtag_t *vsllink_jtag) | |||
(char *)vsllink_usb_in_buffer, VSLLINK_BufferSize, VSLLINK_USB_TIMEOUT); | |||
DEBUG_JTAG_IO("vsllink_usb_read, result = %d", result); | |||
#ifdef _DEBUG_USB_COMMS_ | |||
LOG_DEBUG("USB in:"); | |||
vsllink_debug_buffer(vsllink_usb_in_buffer, result); | |||
@@ -1436,7 +1437,7 @@ void vsllink_debug_buffer(u8 *buffer, int length) | |||
char s[4]; | |||
int i; | |||
int j; | |||
for (i = 0; i < length; i += BYTES_PER_LINE) | |||
{ | |||
snprintf(line, 5, "%04x", i); | |||
@@ -321,7 +321,7 @@ int handle_zy1000_version_command(struct command_context_s *cmd_ctx, char *cmd, | |||
static int | |||
zylinjtag_Jim_Command_powerstatus(Jim_Interp *interp, | |||
int argc, | |||
int argc, | |||
Jim_Obj * const *argv) | |||
{ | |||
if (argc != 1) | |||
@@ -424,9 +424,9 @@ static cyg_uint32 getShiftValueFlip(void) | |||
#endif | |||
#if 0 | |||
static void shiftValueInnerFlip(const enum tap_state state, const enum tap_state endState, int repeat, cyg_uint32 value) | |||
static void shiftValueInnerFlip(const tap_state_t state, const tap_state_t endState, int repeat, cyg_uint32 value) | |||
{ | |||
VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", jtag_state_name(state), jtag_state_name(endState), repeat, value)); | |||
VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state), tap_state_name(endState), repeat, value)); | |||
cyg_uint32 a,b; | |||
a=state; | |||
b=endState; | |||
@@ -443,7 +443,7 @@ static void gotoEndState(void) | |||
setCurrentState(cmd_queue_end_state); | |||
} | |||
static __inline void scanFields(int num_fields, scan_field_t *fields, enum tap_state shiftState, int pause) | |||
static __inline void scanFields(int num_fields, scan_field_t *fields, tap_state_t shiftState, int pause) | |||
{ | |||
int i; | |||
int j; | |||
@@ -487,7 +487,7 @@ static __inline void scanFields(int num_fields, scan_field_t *fields, enum tap_s | |||
j=0; | |||
while (j<num_bits) | |||
{ | |||
enum tap_state pause_state; | |||
tap_state_t pause_state; | |||
int l; | |||
k=num_bits-j; | |||
pause_state=(shiftState==TAP_DRSHIFT)?TAP_DRSHIFT:TAP_IRSHIFT; | |||
@@ -544,13 +544,13 @@ static __inline void scanFields(int num_fields, scan_field_t *fields, enum tap_s | |||
} | |||
} | |||
int interface_jtag_add_end_state(enum tap_state state) | |||
int interface_jtag_add_end_state(tap_state_t state) | |||
{ | |||
return ERROR_OK; | |||
} | |||
int interface_jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int interface_jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
int j; | |||
@@ -614,7 +614,7 @@ int interface_jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_st | |||
int interface_jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int interface_jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
scanFields(num_fields, fields, TAP_IRSHIFT, 1); | |||
gotoEndState(); | |||
@@ -624,7 +624,7 @@ int interface_jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum | |||
/*extern jtag_command_t **jtag_get_last_command_p(void);*/ | |||
int interface_jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int interface_jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
int j; | |||
@@ -667,7 +667,7 @@ int interface_jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_st | |||
return ERROR_OK; | |||
} | |||
int interface_jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int interface_jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
scanFields(num_fields, fields, TAP_DRSHIFT, 1); | |||
gotoEndState(); | |||
@@ -693,7 +693,7 @@ int interface_jtag_add_reset(int req_trst, int req_srst) | |||
return ERROR_OK; | |||
} | |||
static int zy1000_jtag_add_clocks(int num_cycles, enum tap_state state, enum tap_state clockstate) | |||
static int zy1000_jtag_add_clocks(int num_cycles, tap_state_t state, tap_state_t clockstate) | |||
{ | |||
/* num_cycles can be 0 */ | |||
setCurrentState(clockstate); | |||
@@ -715,10 +715,10 @@ static int zy1000_jtag_add_clocks(int num_cycles, enum tap_state state, enum tap | |||
/* finish in end_state */ | |||
setCurrentState(state); | |||
#else | |||
enum tap_state t=TAP_IDLE; | |||
tap_state_t t=TAP_IDLE; | |||
/* test manual drive code on any target */ | |||
int tms; | |||
u8 tms_scan = TAP_MOVE(t, state); | |||
u8 tms_scan = tap_get_tms_path(t, state); | |||
for (i = 0; i < 7; i++) | |||
{ | |||
@@ -734,7 +734,7 @@ static int zy1000_jtag_add_clocks(int num_cycles, enum tap_state state, enum tap | |||
return ERROR_OK; | |||
} | |||
int interface_jtag_add_runtest(int num_cycles, enum tap_state state) | |||
int interface_jtag_add_runtest(int num_cycles, tap_state_t state) | |||
{ | |||
return zy1000_jtag_add_clocks(num_cycles, state, TAP_IDLE); | |||
} | |||
@@ -750,7 +750,7 @@ int interface_jtag_add_sleep(u32 us) | |||
return ERROR_OK; | |||
} | |||
int interface_jtag_add_pathmove(int num_states, enum tap_state *path) | |||
int interface_jtag_add_pathmove(int num_states, tap_state_t *path) | |||
{ | |||
int state_count; | |||
int tms = 0; | |||
@@ -760,21 +760,21 @@ int interface_jtag_add_pathmove(int num_states, enum tap_state *path) | |||
state_count = 0; | |||
enum tap_state cur_state=cmd_queue_cur_state; | |||
tap_state_t cur_state=cmd_queue_cur_state; | |||
while (num_states) | |||
{ | |||
if (tap_transitions[cur_state].low == path[state_count]) | |||
if (tap_state_transition(cur_state, FALSE) == path[state_count]) | |||
{ | |||
tms = 0; | |||
} | |||
else if (tap_transitions[cur_state].high == path[state_count]) | |||
else if (tap_state_transition(cur_state, TRUE) == path[state_count]) | |||
{ | |||
tms = 1; | |||
} | |||
else | |||
{ | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(path[state_count])); | |||
LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[state_count])); | |||
exit(-1); | |||
} | |||
@@ -796,7 +796,7 @@ int interface_jtag_add_pathmove(int num_states, enum tap_state *path) | |||
void embeddedice_write_dcc(jtag_tap_t *tap, int reg_addr, u8 *buffer, int little, int count) | |||
{ | |||
// static int const reg_addr=0x5; | |||
enum tap_state end_state=cmd_queue_end_state; | |||
tap_state_t end_state=cmd_queue_end_state; | |||
if (jtag_NextEnabledTap(jtag_NextEnabledTap(NULL))==NULL) | |||
{ | |||
/* better performance via code duplication */ | |||
@@ -69,7 +69,7 @@ typedef enum | |||
TRST, | |||
}svf_command_t; | |||
const char *svf_command_name[14] = | |||
const char *svf_command_name[14] = | |||
{ | |||
"ENDDR", | |||
"ENDIR", | |||
@@ -137,7 +137,7 @@ typedef struct | |||
}svf_para_t; | |||
svf_para_t svf_para; | |||
const svf_para_t svf_para_init = | |||
const svf_para_t svf_para_init = | |||
{ | |||
// frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode | |||
0, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TRST_Z, | |||
@@ -318,7 +318,7 @@ static int handle_svf_command(struct command_context_s *cmd_ctx, char *cmd, char | |||
memcpy(&svf_para, &svf_para_init, sizeof(svf_para)); | |||
for (i = 0; i < dimof(svf_tap_state_name); i++) | |||
{ | |||
svf_tap_state_name[i] = (char *)jtag_state_name(i); | |||
svf_tap_state_name[i] = (char *)tap_state_name(i); | |||
} | |||
// TAP_RESET | |||
jtag_add_tlr(); | |||
@@ -653,10 +653,10 @@ static int svf_check_tdo(void) | |||
{ | |||
if ((svf_tdi_buffer[index + j] & svf_mask_buffer[index + j]) != svf_tdo_buffer[index + j]) | |||
{ | |||
LOG_ERROR("tdo check error at line %d, read = 0x%X, want = 0x%X, mask = 0x%X", | |||
svf_check_tdo_para[i].line_num, | |||
(*(int*)(svf_tdi_buffer + index)) & ((1 << svf_check_tdo_para[i].bit_len) - 1), | |||
(*(int*)(svf_tdo_buffer + index)) & ((1 << svf_check_tdo_para[i].bit_len) - 1), | |||
LOG_ERROR("tdo check error at line %d, read = 0x%X, want = 0x%X, mask = 0x%X", | |||
svf_check_tdo_para[i].line_num, | |||
(*(int*)(svf_tdi_buffer + index)) & ((1 << svf_check_tdo_para[i].bit_len) - 1), | |||
(*(int*)(svf_tdo_buffer + index)) & ((1 << svf_check_tdo_para[i].bit_len) - 1), | |||
(*(int*)(svf_mask_buffer + index)) & ((1 << svf_check_tdo_para[i].bit_len) - 1)); | |||
return ERROR_FAIL; | |||
} | |||
@@ -872,7 +872,7 @@ static int svf_run_command(struct command_context_s *cmd_ctx, char *cmd_str) | |||
} | |||
LOG_DEBUG("\t%s = 0x%X", argus[i], (**(int**)pbuffer_tmp) & ((1 << (xxr_para_tmp->len)) - 1)); | |||
} | |||
// If a command changes the length of the last scan of the same type and the MASK parameter is absent, | |||
// If a command changes the length of the last scan of the same type and the MASK parameter is absent, | |||
// the mask pattern used is all cares | |||
if (!(xxr_para_tmp->data_mask & XXR_MASK) && (i_tmp != xxr_para_tmp->len)) | |||
{ | |||
@@ -230,9 +230,9 @@ void arm11_dump_reg_changes(arm11_common_t * arm11); | |||
/* internals */ | |||
void arm11_setup_field (arm11_common_t * arm11, int num_bits, void * in_data, void * out_data, scan_field_t * field); | |||
void arm11_add_IR (arm11_common_t * arm11, u8 instr, enum tap_state state); | |||
void arm11_add_debug_SCAN_N (arm11_common_t * arm11, u8 chain, enum tap_state state); | |||
void arm11_add_debug_INST (arm11_common_t * arm11, u32 inst, u8 * flag, enum tap_state state); | |||
void arm11_add_IR (arm11_common_t * arm11, u8 instr, tap_state_t state); | |||
void arm11_add_debug_SCAN_N (arm11_common_t * arm11, u8 chain, tap_state_t state); | |||
void arm11_add_debug_INST (arm11_common_t * arm11, u32 inst, u8 * flag, tap_state_t state); | |||
u32 arm11_read_DSCR (arm11_common_t * arm11); | |||
void arm11_write_DSCR (arm11_common_t * arm11, u32 dscr); | |||
@@ -249,8 +249,8 @@ void arm11_run_instr_data_from_core (arm11_common_t * arm11, u32 opcode, u32 * | |||
void arm11_run_instr_data_from_core_via_r0 (arm11_common_t * arm11, u32 opcode, u32 * data); | |||
void arm11_run_instr_data_to_core_via_r0 (arm11_common_t * arm11, u32 opcode, u32 data); | |||
int arm11_add_dr_scan_vc(int num_fields, scan_field_t *fields, enum tap_state state); | |||
int arm11_add_ir_scan_vc(int num_fields, scan_field_t *fields, enum tap_state state); | |||
int arm11_add_dr_scan_vc(int num_fields, scan_field_t *fields, tap_state_t state); | |||
int arm11_add_ir_scan_vc(int num_fields, scan_field_t *fields, tap_state_t state); | |||
/** Used to make a list of read/write commands for scan chain 7 | |||
* | |||
@@ -36,13 +36,13 @@ | |||
#define JTAG_DEBUG(expr ...) do {} while(0) | |||
#endif | |||
enum tap_state arm11_move_pi_to_si_via_ci[] = | |||
tap_state_t arm11_move_pi_to_si_via_ci[] = | |||
{ | |||
TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IRSHIFT | |||
}; | |||
int arm11_add_ir_scan_vc(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int arm11_add_ir_scan_vc(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
if (cmd_queue_cur_state == TAP_IRPAUSE) | |||
jtag_add_pathmove(asizeof(arm11_move_pi_to_si_via_ci), arm11_move_pi_to_si_via_ci); | |||
@@ -51,12 +51,12 @@ int arm11_add_ir_scan_vc(int num_fields, scan_field_t *fields, enum tap_state st | |||
return ERROR_OK; | |||
} | |||
enum tap_state arm11_move_pd_to_sd_via_cd[] = | |||
tap_state_t arm11_move_pd_to_sd_via_cd[] = | |||
{ | |||
TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT | |||
}; | |||
int arm11_add_dr_scan_vc(int num_fields, scan_field_t *fields, enum tap_state state) | |||
int arm11_add_dr_scan_vc(int num_fields, scan_field_t *fields, tap_state_t state) | |||
{ | |||
if (cmd_queue_cur_state == TAP_DRPAUSE) | |||
jtag_add_pathmove(asizeof(arm11_move_pd_to_sd_via_cd), arm11_move_pd_to_sd_via_cd); | |||
@@ -99,7 +99,7 @@ void arm11_setup_field(arm11_common_t * arm11, int num_bits, void * out_data, vo | |||
* | |||
* \remarks This adds to the JTAG command queue but does \em not execute it. | |||
*/ | |||
void arm11_add_IR(arm11_common_t * arm11, u8 instr, enum tap_state state) | |||
void arm11_add_IR(arm11_common_t * arm11, u8 instr, tap_state_t state) | |||
{ | |||
jtag_tap_t *tap; | |||
tap = arm11->jtag_info.tap; | |||
@@ -167,7 +167,7 @@ static int arm11_in_handler_SCAN_N(u8 *in_value, void *priv, struct scan_field_s | |||
* \remarks This adds to the JTAG command queue but does \em not execute it. | |||
*/ | |||
void arm11_add_debug_SCAN_N(arm11_common_t * arm11, u8 chain, enum tap_state state) | |||
void arm11_add_debug_SCAN_N(arm11_common_t * arm11, u8 chain, tap_state_t state) | |||
{ | |||
JTAG_DEBUG("SCREG <= 0x%02x", chain); | |||
@@ -199,7 +199,7 @@ void arm11_add_debug_SCAN_N(arm11_common_t * arm11, u8 chain, enum tap_state sta | |||
* | |||
* \remarks This adds to the JTAG command queue but does \em not execute it. | |||
*/ | |||
void arm11_add_debug_INST(arm11_common_t * arm11, u32 inst, u8 * flag, enum tap_state state) | |||
void arm11_add_debug_INST(arm11_common_t * arm11, u32 inst, u8 * flag, tap_state_t state) | |||
{ | |||
JTAG_DEBUG("INST <= 0x%08x", inst); | |||
@@ -471,7 +471,7 @@ void arm11_run_instr_data_to_core(arm11_common_t * arm11, u32 opcode, u32 * data | |||
* the core but still shorter than any manually inducible delays. | |||
* | |||
*/ | |||
enum tap_state arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay[] = | |||
tap_state_t arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay[] = | |||
{ | |||
TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT | |||
}; | |||
@@ -318,7 +318,7 @@ int xscale_receive(target_t *target, u32 *buffer, int num_words) | |||
armv4_5_common_t *armv4_5 = target->arch_info; | |||
xscale_common_t *xscale = armv4_5->arch_info; | |||
enum tap_state path[3]; | |||
tap_state_t path[3]; | |||
scan_field_t fields[3]; | |||
u8 *field0 = malloc(num_words * 1); | |||
@@ -427,8 +427,8 @@ int xscale_read_tx(target_t *target, int consume) | |||
{ | |||
armv4_5_common_t *armv4_5 = target->arch_info; | |||
xscale_common_t *xscale = armv4_5->arch_info; | |||
enum tap_state path[3]; | |||
enum tap_state noconsume_path[6]; | |||
tap_state_t path[3]; | |||
tap_state_t noconsume_path[6]; | |||
int retval; | |||
struct timeval timeout, now; | |||
@@ -141,7 +141,7 @@ static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, cha | |||
static int xsvf_fd = 0; | |||
/* map xsvf tap state to an openocd "enum tap_state" */ | |||
/* map xsvf tap state to an openocd "tap_state_t" */ | |||
static tap_state_t xsvf_to_tap( int xsvf_state ) | |||
{ | |||
tap_state_t ret; | |||
@@ -185,7 +185,7 @@ static void xsvf_add_statemove(tap_state_t state) | |||
tap_state_t curstate = cmd_queue_cur_state; | |||
int i; | |||
u8 move = TAP_MOVE(cmd_queue_cur_state, state); | |||
u8 move = tap_get_tms_path(cmd_queue_cur_state, state); | |||
if (state != TAP_RESET && state==cmd_queue_cur_state) | |||
return; | |||
@@ -201,11 +201,11 @@ static void xsvf_add_statemove(tap_state_t state) | |||
int j = (move >> i) & 1; | |||
if (j) | |||
{ | |||
curstate = tap_transitions[curstate].high; | |||
curstate = tap_state_transition(curstate, TRUE); | |||
} | |||
else | |||
{ | |||
curstate = tap_transitions[curstate].low; | |||
curstate = tap_state_transition(curstate, FALSE); | |||
} | |||
moves[i] = curstate; | |||
} | |||
@@ -257,7 +257,7 @@ static int xsvf_read_xstates(int fd, tap_state_t *path, int max_path, int *path_ | |||
mystate = xsvf_to_tap(uc); | |||
LOG_DEBUG("XSTATE %02X %s", uc, jtag_state_name(mystate) ); | |||
LOG_DEBUG("XSTATE %02X %s", uc, tap_state_name(mystate) ); | |||
path[(*path_len)++] = mystate; | |||
} | |||
@@ -581,7 +581,7 @@ static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, cha | |||
mystate = xsvf_to_tap(uc); | |||
LOG_DEBUG("XSTATE 0x%02X %s", uc, jtag_state_name(mystate) ); | |||
LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate) ); | |||
path = calloc(XSTATE_MAX_PATH, 4); | |||
path_len = 1; | |||
@@ -631,14 +631,14 @@ static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, cha | |||
/* see page 22 of XSVF spec */ | |||
mystate = uc == 1 ? TAP_IRPAUSE : TAP_IDLE; | |||
LOG_DEBUG("XENDIR 0x%02X %s", uc, jtag_state_name(mystate)); | |||
LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(mystate)); | |||
/* assuming that the XRUNTEST comes from SVF RUNTEST, then only these states | |||
* should come here because the SVF spec only allows these with a RUNTEST | |||
*/ | |||
if (mystate != TAP_IRPAUSE && mystate != TAP_DRPAUSE && mystate != TAP_RESET && mystate != TAP_IDLE ) | |||
{ | |||
LOG_ERROR("illegal XENDIR endstate: \"%s\"", jtag_state_name(mystate)); | |||
LOG_ERROR("illegal XENDIR endstate: \"%s\"", tap_state_name(mystate)); | |||
unsupported = 1; | |||
break; | |||
} | |||
@@ -659,11 +659,11 @@ static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, cha | |||
/* see page 22 of XSVF spec */ | |||
mystate = uc == 1 ? TAP_DRPAUSE : TAP_IDLE; | |||
LOG_DEBUG("XENDDR %02X %s", uc, jtag_state_name(mystate)); | |||
LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(mystate)); | |||
if (mystate != TAP_IRPAUSE && mystate != TAP_DRPAUSE && mystate != TAP_RESET && mystate != TAP_IDLE ) | |||
{ | |||
LOG_ERROR("illegal XENDDR endstate: \"%s\"", jtag_state_name( mystate )); | |||
LOG_ERROR("illegal XENDDR endstate: \"%s\"", tap_state_name( mystate )); | |||
unsupported = 1; | |||
break; | |||
} | |||
@@ -798,7 +798,7 @@ static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, cha | |||
end_state = xsvf_to_tap(end); | |||
delay = be_to_h_u32(delay_buf); | |||
LOG_DEBUG("XWAIT %s %s usecs:%d", jtag_state_name(wait_state), jtag_state_name(end_state), delay); | |||
LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay); | |||
if (runtest_requires_tck && wait_state == TAP_IDLE ) | |||
{ | |||
@@ -844,8 +844,8 @@ static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, cha | |||
usecs = be_to_h_u32(usecs_buf); | |||
LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i", | |||
jtag_state_name(wait_state), | |||
jtag_state_name(end_state), | |||
tap_state_name(wait_state), | |||
tap_state_name(end_state), | |||
clock_count, usecs); | |||
/* the following states are 'stable', meaning that they have a transition | |||
@@ -855,7 +855,7 @@ static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, cha | |||
*/ | |||
if (wait_state != TAP_IRPAUSE && wait_state != TAP_DRPAUSE && wait_state != TAP_RESET && wait_state != TAP_IDLE) | |||
{ | |||
LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", jtag_state_name( wait_state )); | |||
LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", tap_state_name( wait_state )); | |||
unsupported = 1; | |||
} | |||
@@ -908,7 +908,7 @@ static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, cha | |||
loop_clocks = be_to_h_u32(clock_buf); | |||
loop_usecs = be_to_h_u32(usecs_buf); | |||
LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", jtag_state_name(loop_state), loop_clocks, loop_usecs); | |||
LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs); | |||
} | |||
break; | |||
@@ -704,6 +704,8 @@ try: | |||
nextTok() | |||
if tokVal != ';': | |||
raise ParseError( tokLn, tokVal, "Expecting ';' after TRST trst_mode") | |||
if doCOMMENTs: | |||
writeComment( output, tokLn, 'TRST %s' % trst_mode ) | |||
obuf = bytearray( 2 ) | |||
obuf[0] = XTRST | |||
obuf[1] = trst_mode_allowed.index( trst_mode ) # use the index as the binary argument to XTRST opcode | |||