Browse Source

- Cable driver helper API courtesy of Dick Hollenbeck <dick@softplc.com>

- Formatting changes from uncrustify


git-svn-id: svn://svn.berlios.de/openocd/trunk@1366 b42882b7-edfa-0310-969c-e2dbd0fdcd60
tags/v0.2.0
kc8apf 13 years ago
parent
commit
ab9dfffdb5
21 changed files with 1856 additions and 1509 deletions
  1. +1
    -1
      src/flash/str9xpec.c
  2. +45
    -45
      src/helper/binarybuffer.c
  3. +28
    -24
      src/jtag/amt_jtagaccel.c
  4. +27
    -28
      src/jtag/bitbang.c
  5. +218
    -161
      src/jtag/bitq.c
  6. +2
    -108
      src/jtag/dummy.c
  7. +636
    -543
      src/jtag/ft2232.c
  8. +22
    -22
      src/jtag/gw16012.c
  9. +21
    -21
      src/jtag/jlink.c
  10. +280
    -98
      src/jtag/jtag.c
  11. +340
    -225
      src/jtag/jtag.h
  12. +53
    -53
      src/jtag/rlink/rlink.c
  13. +18
    -18
      src/jtag/usbprog.c
  14. +104
    -103
      src/jtag/vsllink.c
  15. +20
    -20
      src/jtag/zy1000.c
  16. +8
    -8
      src/svf/svf.c
  17. +5
    -5
      src/target/arm11.h
  18. +8
    -8
      src/target/arm11_dbgtap.c
  19. +3
    -3
      src/target/xscale.c
  20. +15
    -15
      src/xsvf/xsvf.c
  21. +2
    -0
      tools/xsvf_tools/svf2xsvf.py

+ 1
- 1
src/flash/str9xpec.c View File

@@ -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;


+ 45
- 45
src/helper/binarybuffer.c View File

@@ -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;
}

+ 28
- 24
src/jtag/amt_jtagaccel.c View File

@@ -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



+ 27
- 28
src/jtag/bitbang.c View File

@@ -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);


+ 218
- 161
src/jtag/bitq.c View File

@@ -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;
}
}

+ 2
- 108
src/jtag/dummy.c View File

@@ -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;
}

+ 636
- 543
src/jtag/ft2232.c
File diff suppressed because it is too large
View File


+ 22
- 22
src/jtag/gw16012.c View File

@@ -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;


+ 21
- 21
src/jtag/jlink.c View File

@@ -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();
}


+ 280
- 98
src/jtag/jtag.c View File

@@ -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;