#endif
-int jtag_flush_queue_count; /* count # of flushes for profiling / debugging purposes */
+/// The number of JTAG queue flushes (for profiling and debugging purposes).
+static int jtag_flush_queue_count;
static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
int in_num_fields, scan_field_t *in_fields, tap_state_t state);
*/
int jtag_error=ERROR_OK;
-typedef struct cmd_queue_page_s
-{
- void *address;
- size_t used;
- struct cmd_queue_page_s *next;
-} cmd_queue_page_t;
-
-#define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
-static cmd_queue_page_t *cmd_queue_pages = NULL;
-
char* jtag_event_strings[] =
{
"JTAG controller reset (RESET or TRST)"
int jtag_trst = 0;
int jtag_srst = 0;
-jtag_command_t *jtag_command_queue = NULL;
-static jtag_command_t **next_command_pointer = &jtag_command_queue;
static jtag_tap_t *jtag_all_taps = NULL;
enum reset_types jtag_reset_config = RESET_NONE;
/* speed in kHz*/
static int speed_khz = 0;
/* flag if the kHz speed was defined */
-static int hasKHz = 0;
+static bool hasKHz = false;
/* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
*/
return ERROR_OK;
}
-void jtag_queue_command(jtag_command_t * cmd)
-{
- // this command goes on the end, so ensure the queue terminates
- cmd->next = NULL;
-
- jtag_command_t **last_cmd = next_command_pointer;
- assert(NULL != last_cmd);
- assert(NULL == *last_cmd);
- *last_cmd = cmd;
-
- // store location where the next command pointer will be stored
- next_command_pointer = &cmd->next;
-}
-
-void* cmd_queue_alloc(size_t size)
-{
- cmd_queue_page_t **p_page = &cmd_queue_pages;
- int offset;
- u8 *t;
-
- /*
- * WARNING:
- * We align/round the *SIZE* per below
- * so that all pointers returned by
- * this function are reasonably well
- * aligned.
- *
- * If we did not, then an "odd-length" request would cause the
- * *next* allocation to be at an *odd* address, and because
- * this function has the same type of api as malloc() - we
- * must also return pointers that have the same type of
- * alignment.
- *
- * What I do not/have is a reasonable portable means
- * to align by...
- *
- * The solution here, is based on these suggestions.
- * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
- *
- */
- union worse_case_align {
- int i;
- long l;
- float f;
- void *v;
- };
-#define ALIGN_SIZE (sizeof(union worse_case_align))
-
- /* The alignment process. */
- size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
- /* Done... */
-
- if (*p_page)
- {
- while ((*p_page)->next)
- p_page = &((*p_page)->next);
- if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
- p_page = &((*p_page)->next);
- }
-
- if (!*p_page)
- {
- *p_page = malloc(sizeof(cmd_queue_page_t));
- (*p_page)->used = 0;
- (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
- (*p_page)->next = NULL;
- }
-
- offset = (*p_page)->used;
- (*p_page)->used += size;
-
- t=(u8 *)((*p_page)->address);
- return t + offset;
-}
-
-void cmd_queue_free(void)
-{
- cmd_queue_page_t *page = cmd_queue_pages;
-
- while (page)
- {
- cmd_queue_page_t *last = page;
- free(page->address);
- page = page->next;
- free(last);
- }
-
- cmd_queue_pages = NULL;
-}
-
-void jtag_command_queue_reset(void)
+static void jtag_checks(void)
{
- cmd_queue_free();
-
- jtag_command_queue = NULL;
- next_command_pointer = &jtag_command_queue;
-}
-
-static void jtag_prelude1(void)
-{
- if (jtag_trst == 1)
- {
- LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
- jtag_error=ERROR_JTAG_TRST_ASSERTED;
- return;
- }
-
- if (cmd_queue_end_state == TAP_RESET)
- jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
+ assert(jtag_trst == 0);
}
static void jtag_prelude(tap_state_t state)
{
- jtag_prelude1();
+ jtag_checks();
- if (state != TAP_INVALID)
- jtag_add_end_state(state);
+ assert(state!=TAP_INVALID);
- cmd_queue_cur_state = cmd_queue_end_state;
+ cmd_queue_cur_state = state;
}
void jtag_alloc_in_value32(scan_field_t *field)
int retval;
jtag_prelude(state);
- retval=interface_jtag_add_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
+ retval=interface_jtag_add_ir_scan(in_num_fields, in_fields, state);
if (retval!=ERROR_OK)
jtag_error=retval;
jtag_prelude(state);
- retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
+ retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, state);
if (retval!=ERROR_OK)
jtag_error=retval;
}
jtag_prelude(state);
- retval=interface_jtag_add_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
+ retval=interface_jtag_add_dr_scan(in_num_fields, in_fields, state);
if (retval!=ERROR_OK)
jtag_error=retval;
}
jtag_prelude(state);
- retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
+ retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, state);
if (retval!=ERROR_OK)
jtag_error=retval;
}
int num_fields, const int* num_bits, const u32* value,
tap_state_t end_state)
{
- if (end_state != TAP_INVALID)
- cmd_queue_end_state = end_state;
+ assert(end_state != TAP_INVALID);
- cmd_queue_cur_state = cmd_queue_end_state;
+ cmd_queue_cur_state = end_state;
interface_jtag_add_dr_out(tap,
num_fields, num_bits, value,
- cmd_queue_end_state);
+ end_state);
}
void jtag_add_tlr(void)
retval=interface_jtag_add_tlr();
if (retval!=ERROR_OK)
jtag_error=retval;
+
+ jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
}
void jtag_add_pathmove(int num_states, const tap_state_t *path)
cur_state = path[i];
}
- jtag_prelude1();
+ jtag_checks();
retval = interface_jtag_add_pathmove(num_states, path);
cmd_queue_cur_state = path[num_states - 1];
jtag_prelude(state);
/* executed by sw or hw fifo */
- retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
+ retval=interface_jtag_add_runtest(num_cycles, state);
if (retval!=ERROR_OK)
jtag_error=retval;
}
if( num_cycles > 0 )
{
- jtag_prelude1();
+ jtag_checks();
retval = interface_jtag_add_clocks(num_cycles);
if (retval != ERROR_OK)
if (trst_with_tlr)
{
LOG_DEBUG("JTAG reset with RESET instead of TRST");
- jtag_add_end_state(TAP_RESET);
+ jtag_set_end_state(TAP_RESET);
jtag_add_tlr();
- jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
return;
}
}
}
-void jtag_add_end_state(tap_state_t state)
+tap_state_t jtag_set_end_state(tap_state_t state)
{
- cmd_queue_end_state = state;
- if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
+ if ((state == TAP_DRSHIFT)||(state == TAP_IRSHIFT))
{
LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
}
+
+ if (state!=TAP_INVALID)
+ cmd_queue_end_state = state;
+ return cmd_queue_end_state;
+}
+
+tap_state_t jtag_get_end_state(void)
+{
+ return cmd_queue_end_state;
}
void jtag_add_sleep(u32 us)
return;
}
-int jtag_scan_size(const scan_command_t *cmd)
-{
- int bit_count = 0;
- int i;
-
- /* count bits in scan command */
- for (i = 0; i < cmd->num_fields; i++)
- {
- bit_count += cmd->fields[i].num_bits;
- }
-
- return bit_count;
-}
-
-int jtag_build_buffer(const scan_command_t *cmd, u8 **buffer)
-{
- int bit_count = 0;
- int i;
-
- bit_count = jtag_scan_size(cmd);
- *buffer = calloc(1,CEIL(bit_count, 8));
-
- bit_count = 0;
-
-#ifdef _DEBUG_JTAG_IO_
- LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields);
-#endif
-
- for (i = 0; i < cmd->num_fields; i++)
- {
- if (cmd->fields[i].out_value)
- {
-#ifdef _DEBUG_JTAG_IO_
- char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : cmd->fields[i].num_bits, 16);
-#endif
- buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
-#ifdef _DEBUG_JTAG_IO_
- LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
- free(char_buf);
-#endif
- }
- else
- {
-#ifdef _DEBUG_JTAG_IO_
- LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits);
-#endif
- }
-
- bit_count += cmd->fields[i].num_bits;
- }
-
-#ifdef _DEBUG_JTAG_IO_
- //LOG_DEBUG("bit_count totalling: %i", bit_count );
-#endif
-
- return bit_count;
-}
-
-int jtag_read_buffer(u8 *buffer, const scan_command_t *cmd)
-{
- int i;
- int bit_count = 0;
- int retval;
-
- /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
- retval = ERROR_OK;
-
- for (i = 0; i < cmd->num_fields; i++)
- {
- /* if neither in_value nor in_handler
- * are specified we don't have to examine this field
- */
- if (cmd->fields[i].in_value)
- {
- int num_bits = cmd->fields[i].num_bits;
- u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
-
-#ifdef _DEBUG_JTAG_IO_
- char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
- LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
- free(char_buf);
-#endif
-
- if (cmd->fields[i].in_value)
- {
- buf_cpy(captured, cmd->fields[i].in_value, num_bits);
- }
-
- free(captured);
- }
- bit_count += cmd->fields[i].num_bits;
- }
-
- return retval;
-}
-
static const char *jtag_tap_name(const jtag_tap_t *tap)
{
return (tap == NULL) ? "(unknown)" : tap->dotted_name;
-enum scan_type jtag_scan_type(const scan_command_t *cmd)
-{
- int i;
- int type = 0;
-
- for (i = 0; i < cmd->num_fields; i++)
- {
- if (cmd->fields[i].in_value)
- type |= SCAN_IN;
- if (cmd->fields[i].out_value)
- type |= SCAN_OUT;
- }
-
- return type;
-}
-
int default_interface_jtag_execute_queue(void)
{
if (NULL == jtag)
return retval;
}
-int jtag_reset_callback(enum jtag_event event, void *priv)
+static int jtag_reset_callback(enum jtag_event event, void *priv)
{
jtag_tap_t *tap = priv;
/* Try to examine chain layout according to IEEE 1149.1 ยง12
*/
-int jtag_examine_chain(void)
+static int jtag_examine_chain(void)
{
jtag_tap_t *tap;
scan_field_t field;
return ERROR_OK;
}
-int jtag_validate_chain(void)
+static int jtag_validate_chain(void)
{
jtag_tap_t *tap;
int total_ir_length = 0;
if(hasKHz)
{
jtag_interface->khz(speed_khz, &jtag_speed);
- hasKHz = 0;
+ hasKHz = false;
}
if (jtag_interface->init() != ERROR_OK)
retval=jtag->speed(cur_speed);
} else
{
- hasKHz = 1;
+ hasKHz = true;
}
} else if (argc==0)
{
command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
return ERROR_COMMAND_SYNTAX_ERROR;
}
- jtag_add_end_state(state);
+ jtag_set_end_state(state);
jtag_execute_queue();
}
command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
return ERROR_COMMAND_SYNTAX_ERROR;
}
- jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
+ jtag_add_runtest(strtol(args[0], NULL, 0), jtag_get_end_state());
jtag_execute_queue();
return ERROR_OK;
jtag_add_pathmove(tms_count, moves);
}
- /* else state must be immediately reachable in one clock cycle, and does not
+ /* else state must be immediately reachable in one clock cycle, and does not
need to be a stable state.
*/
else if( tap_state_transition(cur_state, true) == goal_state
Code Review / openocd.git / blobdiff