Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
add flush_count jtag queue profiling feature
[openocd.git] / src / jtag / jtag.c
diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c
index e02b91f088d5d6a818232c7e2cc3a9de8ec2a1be..649ead4654b6e56353d7d13194b248be65702b31 100644 (file)
--- a/src/jtag/jtag.c
+++ b/src/jtag/jtag.c
@@ -43,7 +43,7 @@
 #endif
 #include <assert.h>
 
-
+int jtag_flush_queue_count; /* count # of flushes for profiling / debugging purposes */
 
 /* note that this is not marked as static as it must be available from outside jtag.c for those
    that implement the jtag_xxx() minidriver layer
@@ -243,6 +243,7 @@ static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cm
 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
+static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args);
 
 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 
@@ -540,6 +541,7 @@ void jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
        u32 id[8];
        int modified[8];
 
+
        /* if we are to run a verification of the ir scan, we need to get the input back.
         * We may have to allocate space if the caller didn't ask for the input back.
         *
@@ -622,8 +624,7 @@ int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields,
                scan_size = tap->ir_length;
                (*last_cmd)->cmd.scan->fields[nth_tap].tap = tap;
                (*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size;
-               (*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL;
-               (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = NULL;       /* disable verification by default */
+               (*last_cmd)->cmd.scan->fields[nth_tap].in_value = fields[nth_tap].in_value;
 
                /* search the list */
                for (j = 0; j < num_fields; j++)
@@ -690,10 +691,6 @@ int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *f
                (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
                (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
                (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
-               (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
-               (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
-               (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
-               (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
        }
        return ERROR_OK;
 }
@@ -772,10 +769,7 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields,
                                (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
                                (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
                                (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
-                               (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
-                               (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
-                               (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
-                               (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
+                               field_count++;
                        }
                }
                if (!found)
@@ -792,10 +786,7 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields,
                        (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
                        (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
                        (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
-                       (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
-                       (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
-                       (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
-                       (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
+                       field_count++;
                }
                else
                {
@@ -881,10 +872,7 @@ void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
                                (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
                                (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
                                (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
-                               (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
-                               (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
-                               (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
-                               (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
+                               field_count++;
                        }
                } else
                {
@@ -900,10 +888,7 @@ void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
                        (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
                        (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
                        (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
-                       (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
-                       (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
-                       (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
-                       (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
+                       field_count++;
                }
        }
 }
@@ -945,10 +930,6 @@ int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *f
                (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
                (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
                (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
-               (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
-               (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
-               (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
-               (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
        }
 
        return ERROR_OK;
@@ -1333,7 +1314,7 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
                /* if neither in_value nor in_handler
                 * are specified we don't have to examine this field
                 */
-               if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
+               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);
@@ -1347,28 +1328,6 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
                        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, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
-                                       {
-                                               LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
-                                               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, 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
-                                        */
-                                       LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s",  cmd->ir_scan ? "SIR" : "SDR" );
-                                       retval = ERROR_JTAG_QUEUE_FAILED;
-                               }
                        }
 
                        free(captured);
@@ -1391,7 +1350,7 @@ int jtag_check_value_inner(u8 *captured, scan_field_t *field, u8 *in_check_value
 
        int compare_failed = 0;
 
-       if (field->in_check_mask)
+       if (in_check_mask)
                compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
        else
                compare_failed = buf_cmp(captured, in_check_value, num_bits);
@@ -1432,26 +1391,6 @@ int jtag_check_value_inner(u8 *captured, scan_field_t *field, u8 *in_check_value
        return retval;
 }
 
-int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
-{
-       return jtag_check_value_inner(captured, field, field->in_check_value, field->in_check_mask);
-}
-
-/*
-  set up checking of this field using the in_handler. The values passed in must be valid until
-  after jtag_execute() has completed.
- */
-void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, struct invalidstruct *obsolete)
-{
-       if (value)
-               field->in_handler = jtag_check_value;
-       else
-               field->in_handler = NULL;       /* No check, e.g. embeddedice uses value==NULL to indicate no check */
-       field->in_handler_priv = NULL;
-       field->in_check_value = value;
-       field->in_check_mask = mask;
-}
-
 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
 {
        assert(field->in_value != NULL);
@@ -1466,7 +1405,6 @@ void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
 
        int retval=jtag_check_value_inner(field->in_value, field, value, mask);
        jtag_set_error(retval);
-
 }
 
 
@@ -1478,7 +1416,7 @@ enum scan_type jtag_scan_type(scan_command_t *cmd)
 
        for (i = 0; i < cmd->num_fields; i++)
        {
-               if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
+               if (cmd->fields[i].in_value)
                        type |= SCAN_IN;
                if (cmd->fields[i].out_value)
                        type |= SCAN_OUT;
@@ -1509,6 +1447,11 @@ int MINIDRIVER(interface_jtag_execute_queue)(void)
 
 void jtag_execute_queue_noclear(void)
 {
+       /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
+        * E.g. a JTAG over TCP/IP or USB....
+        */
+       jtag_flush_queue_count++; 
+
        int retval=interface_jtag_execute_queue();
        /* we keep the first error */
        if ((jtag_error==ERROR_OK)&&(retval!=ERROR_OK))
@@ -1566,7 +1509,7 @@ int jtag_examine_chain(void)
        field.in_value = idcode_buffer;
 
 
-       field.in_handler = NULL;
+
 
        for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
        {
@@ -1740,7 +1683,7 @@ int jtag_validate_chain(void)
        field.num_bits = total_ir_length;
        field.out_value = ir_test;
        field.in_value = ir_test;
-       field.in_handler = NULL;
+
 
        jtag_add_plain_ir_scan(1, &field, TAP_RESET);
        jtag_execute_queue();
@@ -2243,6 +2186,7 @@ int jtag_register_commands(struct command_context_s *cmd_ctx)
        register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
                COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
        register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
+       register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count, "returns number of times the JTAG queue has been flushed");
 
        register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
                COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
@@ -2858,9 +2802,6 @@ static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, c
                fields[i].out_value = malloc(CEIL(field_size, 8));
                buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
                fields[i].in_value = NULL;
-               fields[i].in_check_mask = NULL;
-               fields[i].in_handler = NULL;
-               fields[i].in_handler_priv = NULL;
        }
 
        jtag_add_ir_scan(argc / 2, fields, TAP_INVALID);
@@ -2973,10 +2914,7 @@ static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args
                fields[field_count].out_value = malloc(CEIL(bits, 8));
                str_to_buf(str, len, fields[field_count].out_value, bits, 0);
                fields[field_count].in_value = fields[field_count].out_value;
-               fields[field_count].in_check_mask = NULL;
-               fields[field_count].in_check_value = NULL;
-               fields[field_count].in_handler = NULL;
-               fields[field_count++].in_handler_priv = NULL;
+               field_count++;
        }
 
        jtag_add_dr_scan(num_fields, fields, TAP_INVALID);
@@ -3014,6 +2952,15 @@ static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args
        return JIM_OK;
 }
 
+
+static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
+{
+       Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_flush_queue_count));
+
+       return JIM_OK;
+}
+
+
 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        if (argc == 1)
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)