device = device->next;
i++;
}
-
- return NULL;
+
+ ERROR("jtag device number %d not defined", num);
+ exit(-1);
}
void* cmd_queue_alloc(size_t size)
offset = (*p_page)->used;
(*p_page)->used += size;
- return ((*p_page)->address) + offset;
+ u8 *t=(u8 *)((*p_page)->address);
+ return t + offset;
}
void cmd_queue_free()
(*last_cmd)->cmd.scan->fields[i].device = i;
(*last_cmd)->cmd.scan->fields[i].num_bits = scan_size;
(*last_cmd)->cmd.scan->fields[i].in_value = NULL;
- (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
- (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
- if (jtag_verify_capture_ir)
- {
- jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL);
- }
+ (*last_cmd)->cmd.scan->fields[i].in_handler = NULL; /* disable verification by default */
/* search the list */
for (j = 0; j < num_fields; j++)
found = 1;
(*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
(*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
+
+ if (jtag_verify_capture_ir)
+ {
+ if (fields[j].in_handler==NULL)
+ {
+ jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL);
+ } else
+ {
+ (*last_cmd)->cmd.scan->fields[i].in_handler = fields[j].in_handler;
+ (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[j].in_handler_priv;
+ (*last_cmd)->cmd.scan->fields[i].in_check_value = device->expected;
+ (*last_cmd)->cmd.scan->fields[i].in_check_mask = device->expected_mask;
+ }
+ }
device->bypass = 0;
break;
return ERROR_JTAG_NOT_IMPLEMENTED;
}
- if (jtag->support_pathmove)
- {
- /* allocate memory for a new list member */
- *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
- last_comand_pointer = &((*last_cmd)->next);
- (*last_cmd)->next = NULL;
- (*last_cmd)->type = JTAG_PATHMOVE;
+ /* allocate memory for a new list member */
+ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
+ last_comand_pointer = &((*last_cmd)->next);
+ (*last_cmd)->next = NULL;
+ (*last_cmd)->type = JTAG_PATHMOVE;
+
+ (*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 = 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);
-
- for (i = 0; i < num_states; i++)
- (*last_cmd)->cmd.pathmove->path[i] = path[i];
- }
- else
- {
- /* validate the desired path, and see if it fits a default path */
- int begin = 0;
- int end = 0;
- int j;
-
- for (i = 0; i < num_states; i++)
- {
- for (j = i; j < num_states; j++)
- {
- if (tap_move_map[path[j]] != -1)
- {
- end = j;
- break;
- }
- }
-
- if (begin - end <= 7) /* a default path spans no more than 7 states */
- {
- jtag_add_statemove(path[end]);
- }
- else
- {
- ERROR("encountered a TAP path that can't be fulfilled by default paths");
- return ERROR_JTAG_NOT_IMPLEMENTED;
- }
-
- i = end;
- }
- }
+ for (i = 0; i < num_states; i++)
+ (*last_cmd)->cmd.pathmove->path[i] = path[i];
if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
jtag_call_event_callbacks(JTAG_TRST_RELEASED);
}
-extern int jtag_check_value(u8 *captured, void *priv);
-
int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
{
int i;
free(char_buf);
#endif
- void *priv = cmd->fields[i].in_handler_priv;
- if (cmd->fields[i].in_handler == &jtag_check_value)
- {
- /* Yuk! we want to pass in the pointer to cmd->fields[i] which is not known
- * when jtag_check_value is invoked
- *
- * Not pretty, but this is part of synthesizing check_mask via in_handler
- * with a minimum of code impact.
- *
- * A cleaner change would be to modify the in_handler to always take field
- * as an argument. Perhaps later...
- *
- * Change in_handler to be varargs and have fields+i as the first vararg?
- *
- */
- priv = cmd->fields + i;
- }
if (cmd->fields[i].in_value)
{
buf_cpy(captured, cmd->fields[i].in_value, num_bits);
if (cmd->fields[i].in_handler)
{
- if (cmd->fields[i].in_handler(cmd->fields[i].in_value, priv) != ERROR_OK)
+ if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
{
WARNING("in_handler reported a failed check");
retval = ERROR_JTAG_QUEUE_FAILED;
/* no in_value specified, but a handler takes care of the scanned data */
if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
{
- if (cmd->fields[i].in_handler(captured, priv) != ERROR_OK)
+ if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
{
/* We're going to call the error:handler later, but if the in_handler
* reported an error we report this failure upstream
return retval;
}
-int jtag_check_value(u8 *captured, void *priv)
+int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
{
int retval = ERROR_OK;
- scan_field_t *field=(scan_field_t *)priv;
int num_bits = field->num_bits;
int compare_failed = 0;
compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
if (compare_failed)
- {
- if (field->in_handler_error_handler.error_handler)
- {
- /* ask the error handler if once has been specified if this is a real problem */
- if (field->in_handler_error_handler.error_handler(captured, field->in_handler_error_handler.error_handler_priv) != ERROR_OK)
- retval = ERROR_JTAG_QUEUE_FAILED;
- else
- compare_failed = 0;
- }
- else
{
- /* if there wasn't a handler specified, we report a failure */
- retval = ERROR_JTAG_QUEUE_FAILED;
- }
-
/* An error handler could have caught the failing check
* only report a problem when there wasn't a handler, or if the handler
* acknowledged the error
free(captured_char);
free(in_check_value_char);
+
+ retval = ERROR_JTAG_QUEUE_FAILED;
}
}
field->in_handler_priv = NULL; /* this will be filled in at the invocation site to point to the field duplicate */
field->in_check_value = value;
field->in_check_mask = mask;
- if (in_error_handler)
- field->in_handler_error_handler = *in_error_handler;
- else
- field->in_handler_error_handler.error_handler = NULL;
}
enum scan_type jtag_scan_type(scan_command_t *cmd)
return retval;
}
-int jtag_cancel_queue(void)
-{
- cmd_queue_free();
- jtag_command_queue = NULL;
- last_comand_pointer = &jtag_command_queue;
-
- return ERROR_OK;
-}
-
int jtag_reset_callback(enum jtag_event event, void *priv)
{
jtag_device_t *device = priv;
register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
COMMAND_ANY, "set jtag speed (if supported) <speed>");
register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
- COMMAND_CONFIG, NULL);
+ COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
COMMAND_CONFIG, NULL);
register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
Code Review / openocd.git / blobdiff