2 * Copyright (C) 2009 by Simon Qian
3 * SimonQian@SimonQian.com
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 /* The specification for SVF is available here:
22 * http://www.asset-intertech.com/support/svf.pdf
23 * Below, this document is refered to as the "SVF spec".
25 * The specification for XSVF is available here:
26 * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
27 * Below, this document is refered to as the "XSVF spec".
34 #include <jtag/jtag.h>
36 #include <helper/time_support.h>
58 static const char *svf_command_name
[14] =
84 static const char *svf_trst_mode_name
[4] =
96 uint32_t num_of_moves
;
101 * These paths are from the SVF specification for the STATE command, to be
102 * used when the STATE command only includes the final state. The first
103 * element of the path is the "from" (current) state, and the last one is
104 * the "to" (target) state.
106 * All specified paths are the shortest ones in the JTAG spec, and are thus
107 * not (!!) exact matches for the paths used elsewhere in OpenOCD. Note
108 * that PAUSE-to-PAUSE transitions all go through UPDATE and then CAPTURE,
109 * which has specific effects on the various registers; they are not NOPs.
111 * Paths to RESET are disabled here. As elsewhere in OpenOCD, and in XSVF
112 * and many SVF implementations, we don't want to risk missing that state.
113 * To get to RESET, always we ignore the current state.
115 static const struct svf_statemove svf_statemoves
[] =
117 // from to num_of_moves, paths[8]
118 // {TAP_RESET, TAP_RESET, 1, {TAP_RESET}},
119 {TAP_RESET
, TAP_IDLE
, 2, {TAP_RESET
, TAP_IDLE
}},
120 {TAP_RESET
, TAP_DRPAUSE
, 6, {TAP_RESET
, TAP_IDLE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DREXIT1
, TAP_DRPAUSE
}},
121 {TAP_RESET
, TAP_IRPAUSE
, 7, {TAP_RESET
, TAP_IDLE
, TAP_DRSELECT
, TAP_IRSELECT
, TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
}},
123 // {TAP_IDLE, TAP_RESET, 4, {TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
124 {TAP_IDLE
, TAP_IDLE
, 1, {TAP_IDLE
}},
125 {TAP_IDLE
, TAP_DRPAUSE
, 5, {TAP_IDLE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DREXIT1
, TAP_DRPAUSE
}},
126 {TAP_IDLE
, TAP_IRPAUSE
, 6, {TAP_IDLE
, TAP_DRSELECT
, TAP_IRSELECT
, TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
}},
128 // {TAP_DRPAUSE, TAP_RESET, 6, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
129 {TAP_DRPAUSE
, TAP_IDLE
, 4, {TAP_DRPAUSE
, TAP_DREXIT2
, TAP_DRUPDATE
, TAP_IDLE
}},
130 {TAP_DRPAUSE
, TAP_DRPAUSE
, 7, {TAP_DRPAUSE
, TAP_DREXIT2
, TAP_DRUPDATE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DREXIT1
, TAP_DRPAUSE
}},
131 {TAP_DRPAUSE
, TAP_IRPAUSE
, 8, {TAP_DRPAUSE
, TAP_DREXIT2
, TAP_DRUPDATE
, TAP_DRSELECT
, TAP_IRSELECT
, TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
}},
133 // {TAP_IRPAUSE, TAP_RESET, 6, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
134 {TAP_IRPAUSE
, TAP_IDLE
, 4, {TAP_IRPAUSE
, TAP_IREXIT2
, TAP_IRUPDATE
, TAP_IDLE
}},
135 {TAP_IRPAUSE
, TAP_DRPAUSE
, 7, {TAP_IRPAUSE
, TAP_IREXIT2
, TAP_IRUPDATE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DREXIT1
, TAP_DRPAUSE
}},
136 {TAP_IRPAUSE
, TAP_IRPAUSE
, 8, {TAP_IRPAUSE
, TAP_IREXIT2
, TAP_IRUPDATE
, TAP_DRSELECT
, TAP_IRSELECT
, TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
}}
140 #define XXR_TDI (1 << 0)
141 #define XXR_TDO (1 << 1)
142 #define XXR_MASK (1 << 2)
143 #define XXR_SMASK (1 << 3)
157 tap_state_t ir_end_state
;
158 tap_state_t dr_end_state
;
159 tap_state_t runtest_run_state
;
160 tap_state_t runtest_end_state
;
161 trst_mode_t trst_mode
;
163 struct svf_xxr_para hir_para
;
164 struct svf_xxr_para hdr_para
;
165 struct svf_xxr_para tir_para
;
166 struct svf_xxr_para tdr_para
;
167 struct svf_xxr_para sir_para
;
168 struct svf_xxr_para sdr_para
;
171 static struct svf_para svf_para
;
172 static const struct svf_para svf_para_init
=
174 // frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode
175 0, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TRST_Z
,
177 // {len, data_mask, tdi, tdo, mask, smask},
178 {0, 0, NULL
, NULL
, NULL
, NULL
},
180 // {len, data_mask, tdi, tdo, mask, smask},
181 {0, 0, NULL
, NULL
, NULL
, NULL
},
183 // {len, data_mask, tdi, tdo, mask, smask},
184 {0, 0, NULL
, NULL
, NULL
, NULL
},
186 // {len, data_mask, tdi, tdo, mask, smask},
187 {0, 0, NULL
, NULL
, NULL
, NULL
},
189 // {len, data_mask, tdi, tdo, mask, smask},
190 {0, 0, NULL
, NULL
, NULL
, NULL
},
192 // {len, data_mask, tdi, tdo, mask, smask},
193 {0, 0, NULL
, NULL
, NULL
, NULL
},
196 struct svf_check_tdo_para
198 int line_num
; // used to record line number of the check operation
199 // so more information could be printed
200 int enabled
; // check is enabled or not
201 int buffer_offset
; // buffer_offset to buffers
202 int bit_len
; // bit length to check
205 #define SVF_CHECK_TDO_PARA_SIZE 1024
206 static struct svf_check_tdo_para
*svf_check_tdo_para
= NULL
;
207 static int svf_check_tdo_para_index
= 0;
209 static int svf_read_command_from_file(FILE * fd
);
210 static int svf_check_tdo(void);
211 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
);
212 static int svf_run_command(struct command_context
*cmd_ctx
, char *cmd_str
);
214 static FILE * svf_fd
= NULL
;
215 static char * svf_read_line
= NULL
;
216 static size_t svf_read_line_size
= 0;
217 static char *svf_command_buffer
= NULL
;
218 static size_t svf_command_buffer_size
= 0;
219 static int svf_line_number
= 1;
220 static int svf_getline (char **lineptr
, size_t *n
, FILE *stream
);
222 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (4 * 1024)
223 static uint8_t *svf_tdi_buffer
= NULL
, *svf_tdo_buffer
= NULL
, *svf_mask_buffer
= NULL
;
224 static int svf_buffer_index
= 0, svf_buffer_size
= 0;
225 static int svf_quiet
= 0;
227 // Targetting particular tap
228 static int svf_tap_is_specified
= 0;
229 static int svf_set_padding(struct svf_xxr_para
*para
, int len
, unsigned char tdi
);
231 // Progress Indicator
232 static int svf_progress_enabled
= 0;
233 static long svf_total_lines
= 0;
234 static int svf_percentage
= 0;
235 static int svf_last_printed_percentage
= -1;
237 static void svf_free_xxd_para(struct svf_xxr_para
*para
)
241 if (para
->tdi
!= NULL
)
246 if (para
->tdo
!= NULL
)
251 if (para
->mask
!= NULL
)
256 if (para
->smask
!= NULL
)
264 static unsigned svf_get_mask_u32(int bitlen
)
272 else if (bitlen
>= 32)
274 bitmask
= 0xFFFFFFFF;
278 bitmask
= (1 << bitlen
) - 1;
284 int svf_add_statemove(tap_state_t state_to
)
286 tap_state_t state_from
= cmd_queue_cur_state
;
289 /* when resetting, be paranoid and ignore current state */
290 if (state_to
== TAP_RESET
) {
295 for (index_var
= 0; index_var
< ARRAY_SIZE(svf_statemoves
); index_var
++)
297 if ((svf_statemoves
[index_var
].from
== state_from
)
298 && (svf_statemoves
[index_var
].to
== state_to
))
300 /* recorded path includes current state ... avoid extra TCKs! */
301 if (svf_statemoves
[index_var
].num_of_moves
> 1)
302 jtag_add_pathmove(svf_statemoves
[index_var
].num_of_moves
- 1,
303 svf_statemoves
[index_var
].paths
+ 1);
305 jtag_add_pathmove(svf_statemoves
[index_var
].num_of_moves
,
306 svf_statemoves
[index_var
].paths
);
310 LOG_ERROR("SVF: can not move to %s", tap_state_name(state_to
));
314 COMMAND_HANDLER(handle_svf_command
)
316 #define SVF_MIN_NUM_OF_OPTIONS 1
317 #define SVF_MAX_NUM_OF_OPTIONS 5
318 #define USAGE [-tap device.tap] <file> [quiet] [progress]
319 #define PRINT_USAGE command_print(CMD_CTX, "svf USAGE")
322 long long time_measure_ms
;
323 int time_measure_s
, time_measure_m
;
325 /* use NULL to indicate a "plain" svf file which accounts for
326 any additional devices in the scan chain, otherwise the device
327 that should be affected
329 struct jtag_tap
*tap
= NULL
;
331 if ((CMD_ARGC
< SVF_MIN_NUM_OF_OPTIONS
) || (CMD_ARGC
> SVF_MAX_NUM_OF_OPTIONS
))
337 // parse command line
339 for (unsigned int i
= 0; i
< CMD_ARGC
; i
++)
341 if (strcmp(CMD_ARGV
[i
], "-tap") == 0)
343 tap
= jtag_tap_by_string(CMD_ARGV
[i
+1]);
346 command_print(CMD_CTX
, "Tap: %s unknown", CMD_ARGV
[i
+1]);
351 else if ((strcmp(CMD_ARGV
[i
], "quiet") == 0) || (strcmp(CMD_ARGV
[i
], "-quiet") == 0))
355 else if ((strcmp(CMD_ARGV
[i
], "progress") == 0) || (strcmp(CMD_ARGV
[i
], "-progress") == 0))
357 svf_progress_enabled
= 1;
359 else if ((svf_fd
= fopen(CMD_ARGV
[i
], "r")) == NULL
)
363 command_print(CMD_CTX
, "open(\"%s\"): %s", CMD_ARGV
[i
], strerror(err
));
364 // no need to free anything now
369 LOG_USER("svf processing file: \"%s\"", CMD_ARGV
[i
]);
380 time_measure_ms
= timeval_ms();
384 svf_command_buffer_size
= 0;
386 svf_check_tdo_para_index
= 0;
387 svf_check_tdo_para
= malloc(sizeof(struct svf_check_tdo_para
) * SVF_CHECK_TDO_PARA_SIZE
);
388 if (NULL
== svf_check_tdo_para
)
390 LOG_ERROR("not enough memory");
395 svf_buffer_index
= 0;
396 // double the buffer size
397 // in case current command cannot be commited, and next command is a bit scan command
398 // here is 32K bits for this big scan command, it should be enough
399 // buffer will be reallocated if buffer size is not enough
400 svf_tdi_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
401 if (NULL
== svf_tdi_buffer
)
403 LOG_ERROR("not enough memory");
407 svf_tdo_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
408 if (NULL
== svf_tdo_buffer
)
410 LOG_ERROR("not enough memory");
414 svf_mask_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
415 if (NULL
== svf_mask_buffer
)
417 LOG_ERROR("not enough memory");
421 svf_buffer_size
= 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
;
423 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
430 /* Tap is specified, set header/trailer paddings */
431 int header_ir_len
= 0, header_dr_len
= 0, trailer_ir_len
= 0, trailer_dr_len
= 0;
432 struct jtag_tap
*check_tap
;
434 svf_tap_is_specified
= 1;
436 for (check_tap
= jtag_all_taps(); check_tap
; check_tap
= check_tap
->next_tap
) {
437 if (check_tap
->abs_chain_position
< tap
->abs_chain_position
)
440 header_ir_len
+= check_tap
->ir_length
;
443 else if (check_tap
->abs_chain_position
> tap
->abs_chain_position
)
446 trailer_ir_len
+= check_tap
->ir_length
;
452 if (ERROR_OK
!= svf_set_padding(&svf_para
.hdr_para
, header_dr_len
, 0))
454 LOG_ERROR("failed to set data header");
459 if (ERROR_OK
!= svf_set_padding(&svf_para
.hir_para
, header_ir_len
, 0xFF))
461 LOG_ERROR("failed to set instruction header");
466 if (ERROR_OK
!= svf_set_padding(&svf_para
.tdr_para
, trailer_dr_len
, 0))
468 LOG_ERROR("failed to set data trailer");
473 if (ERROR_OK
!= svf_set_padding(&svf_para
.tir_para
, trailer_ir_len
, 0xFF))
475 LOG_ERROR("failed to set instruction trailer");
481 if (svf_progress_enabled
)
483 // Count total lines in file.
484 while ( ! feof (svf_fd
) )
486 svf_getline (&svf_command_buffer
, &svf_command_buffer_size
, svf_fd
);
491 while (ERROR_OK
== svf_read_command_from_file(svf_fd
))
496 if (svf_progress_enabled
)
498 svf_percentage
= ((svf_line_number
* 20) / svf_total_lines
) * 5;
499 if (svf_last_printed_percentage
!= svf_percentage
)
501 LOG_USER_N("\r%d%% ", svf_percentage
);
502 svf_last_printed_percentage
= svf_percentage
;
508 if (svf_progress_enabled
)
510 svf_percentage
= ((svf_line_number
* 20) / svf_total_lines
) * 5;
511 LOG_USER_N("%3d%% %s", svf_percentage
, svf_read_line
);
515 LOG_USER_N("%s",svf_read_line
);
519 if (ERROR_OK
!= svf_run_command(CMD_CTX
, svf_command_buffer
))
521 LOG_ERROR("fail to run command at line %d", svf_line_number
);
527 if (ERROR_OK
!= jtag_execute_queue())
531 else if (ERROR_OK
!= svf_check_tdo())
537 time_measure_ms
= timeval_ms() - time_measure_ms
;
538 time_measure_s
= time_measure_ms
/ 1000;
539 time_measure_ms
%= 1000;
540 time_measure_m
= time_measure_s
/ 60;
541 time_measure_s
%= 60;
542 if (time_measure_ms
< 1000)
544 command_print(CMD_CTX
, "\r\nTime used: %dm%ds%lldms ", time_measure_m
, time_measure_s
, time_measure_ms
);
553 if (svf_command_buffer
)
555 free(svf_command_buffer
);
556 svf_command_buffer
= NULL
;
557 svf_command_buffer_size
= 0;
559 if (svf_check_tdo_para
)
561 free(svf_check_tdo_para
);
562 svf_check_tdo_para
= NULL
;
563 svf_check_tdo_para_index
= 0;
567 free(svf_tdi_buffer
);
568 svf_tdi_buffer
= NULL
;
572 free(svf_tdo_buffer
);
573 svf_tdo_buffer
= NULL
;
577 free(svf_mask_buffer
);
578 svf_mask_buffer
= NULL
;
580 svf_buffer_index
= 0;
583 svf_free_xxd_para(&svf_para
.hdr_para
);
584 svf_free_xxd_para(&svf_para
.hir_para
);
585 svf_free_xxd_para(&svf_para
.tdr_para
);
586 svf_free_xxd_para(&svf_para
.tir_para
);
587 svf_free_xxd_para(&svf_para
.sdr_para
);
588 svf_free_xxd_para(&svf_para
.sir_para
);
592 command_print(CMD_CTX
, "svf file programmed successfully for %d commands", command_num
);
596 command_print(CMD_CTX
, "svf file programmed failed");
602 static int svf_getline (char **lineptr
, size_t *n
, FILE *stream
)
604 #define MIN_CHUNK 16 //Buffer is increased by this size each time as required
607 if (*lineptr
== NULL
)
610 *lineptr
= (char *)malloc (*n
);
617 (*lineptr
)[0] = fgetc(stream
);
618 while ((*lineptr
)[i
] != '\n')
620 (*lineptr
)[++i
] = fgetc(stream
);
629 *lineptr
= realloc(*lineptr
, *n
);
635 return sizeof(*lineptr
);
638 #define SVFP_CMD_INC_CNT 1024
639 static int svf_read_command_from_file(FILE * fd
)
644 int cmd_ok
= 0, slash
= 0, comment
= 0;
646 if (svf_getline (&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
651 ch
= svf_read_line
[0];
652 while (!cmd_ok
&& (ch
!= 0))
658 if (svf_getline (&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
669 if (svf_getline (&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
683 if (svf_getline (&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
691 /* Don't save '\r' and '\n' if no data is parsed */
695 /* The parsing code currently expects a space
696 * before parentheses -- "TDI (123)". Also a
697 * space afterwards -- "TDI (123) TDO(456)".
698 * But such spaces are optional... instead of
699 * parser updates, cope with that by adding the
702 * Ensure there are 3 bytes available, for:
703 * - current character
705 * - terminating NUL ('\0')
707 if ((cmd_pos
+ 2) >= svf_command_buffer_size
)
709 svf_command_buffer
= realloc(svf_command_buffer
, (cmd_pos
+ 2));
710 if (svf_command_buffer
== NULL
)
712 LOG_ERROR("not enough memory");
717 /* insert a space before '(' */
719 svf_command_buffer
[cmd_pos
++] = ' ';
721 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
723 /* insert a space after ')' */
725 svf_command_buffer
[cmd_pos
++] = ' ';
728 ch
= svf_read_line
[++i
];
733 svf_command_buffer
[cmd_pos
] = '\0';
742 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
744 int pos
= 0, num
= 0, space_found
= 1, in_bracket
= 0;
752 LOG_ERROR("fail to parse svf command");
762 if (!in_bracket
&& isspace((int) str
[pos
]))
767 else if (space_found
)
769 argus
[num
++] = &str
[pos
];
782 bool svf_tap_state_is_stable(tap_state_t state
)
784 return (TAP_RESET
== state
) || (TAP_IDLE
== state
)
785 || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
);
788 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
792 for (i
= 0; i
< num_of_element
; i
++)
794 if (!strcmp(str
, strs
[i
]))
802 static int svf_adjust_array_length(uint8_t **arr
, int orig_bit_len
, int new_bit_len
)
804 int new_byte_len
= (new_bit_len
+ 7) >> 3;
806 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3)))
813 *arr
= (uint8_t*)malloc(new_byte_len
);
816 LOG_ERROR("not enough memory");
819 memset(*arr
, 0, new_byte_len
);
824 static int svf_set_padding(struct svf_xxr_para
*para
, int len
, unsigned char tdi
)
826 int error
= ERROR_OK
;
827 error
|= svf_adjust_array_length(¶
->tdi
, para
->len
, len
);
828 memset(para
->tdi
, tdi
, (len
+ 7) >> 3);
829 error
|= svf_adjust_array_length(¶
->tdo
, para
->len
, len
);
830 error
|= svf_adjust_array_length(¶
->mask
, para
->len
, len
);
832 para
->data_mask
= XXR_TDI
;
837 static int svf_copy_hexstring_to_binary(char *str
, uint8_t **bin
, int orig_bit_len
, int bit_len
)
839 int i
, str_len
= strlen(str
), str_hbyte_len
= (bit_len
+ 3) >> 2;
842 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
))
844 LOG_ERROR("fail to adjust length of array");
848 /* fill from LSB (end of str) to MSB (beginning of str) */
849 for (i
= 0; i
< str_hbyte_len
; i
++)
856 /* Skip whitespace. The SVF specification (rev E) is
857 * deficient in terms of basic lexical issues like
858 * where whitespace is allowed. Long bitstrings may
859 * require line ends for correctness, since there is
860 * a hard limit on line length.
864 if ((ch
>= '0') && (ch
<= '9'))
869 else if ((ch
>= 'A') && (ch
<= 'F'))
876 LOG_ERROR("invalid hex string");
888 (*bin
)[i
/ 2] |= ch
<< 4;
898 /* consume optional leading '0' MSBs or whitespace */
899 while (str_len
> 0 && ((str
[str_len
- 1] == '0')
900 || isspace((int) str
[str_len
- 1])))
903 /* check validity: we must have consumed everything */
904 if (str_len
> 0 || (ch
& ~((2 << ((bit_len
- 1) % 4)) - 1)) != 0)
906 LOG_ERROR("value execeeds length");
913 static int svf_check_tdo(void)
915 int i
, len
, index_var
;
917 for (i
= 0; i
< svf_check_tdo_para_index
; i
++)
919 index_var
= svf_check_tdo_para
[i
].buffer_offset
;
920 len
= svf_check_tdo_para
[i
].bit_len
;
921 if ((svf_check_tdo_para
[i
].enabled
)
922 && buf_cmp_mask(&svf_tdi_buffer
[index_var
], &svf_tdo_buffer
[index_var
], &svf_mask_buffer
[index_var
], len
))
925 unsigned received
, expected
, tapmask
;
926 bitmask
= svf_get_mask_u32(svf_check_tdo_para
[i
].bit_len
);
928 memcpy(&received
, svf_tdi_buffer
+ index_var
, sizeof(unsigned));
929 memcpy(&expected
, svf_tdo_buffer
+ index_var
, sizeof(unsigned));
930 memcpy(&tapmask
, svf_mask_buffer
+ index_var
, sizeof(unsigned));
931 LOG_ERROR("tdo check error at line %d",
932 svf_check_tdo_para
[i
].line_num
);
933 LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
940 svf_check_tdo_para_index
= 0;
945 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
)
947 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
949 LOG_ERROR("toooooo many operation undone");
953 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
954 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
955 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
956 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
957 svf_check_tdo_para_index
++;
962 static int svf_execute_tap(void)
964 if (ERROR_OK
!= jtag_execute_queue())
968 else if (ERROR_OK
!= svf_check_tdo())
973 svf_buffer_index
= 0;
978 static int svf_run_command(struct command_context
*cmd_ctx
, char *cmd_str
)
980 char *argus
[256], command
;
981 int num_of_argu
= 0, i
;
988 float min_time
, max_time
;
990 struct svf_xxr_para
*xxr_para_tmp
;
991 uint8_t **pbuffer_tmp
;
992 struct scan_field field
;
994 tap_state_t
*path
= NULL
, state
;
995 // flag padding commands skipped due to -tap command
996 int padding_command_skipped
= 0;
998 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
1003 /* NOTE: we're a bit loose here, because we ignore case in
1004 * TAP state names (instead of insisting on uppercase).
1007 command
= svf_find_string_in_array(argus
[0],
1008 (char **)svf_command_name
, ARRAY_SIZE(svf_command_name
));
1013 if (num_of_argu
!= 2)
1015 LOG_ERROR("invalid parameter of %s", argus
[0]);
1019 i_tmp
= tap_state_by_name(argus
[1]);
1021 if (svf_tap_state_is_stable(i_tmp
))
1023 if (command
== ENDIR
)
1025 svf_para
.ir_end_state
= i_tmp
;
1026 LOG_DEBUG("\tIR end_state = %s",
1027 tap_state_name(i_tmp
));
1031 svf_para
.dr_end_state
= i_tmp
;
1032 LOG_DEBUG("\tDR end_state = %s",
1033 tap_state_name(i_tmp
));
1038 LOG_ERROR("%s: %s is not a stable state",
1039 argus
[0], argus
[1]);
1044 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
1046 LOG_ERROR("invalid parameter of %s", argus
[0]);
1049 if (1 == num_of_argu
)
1051 // TODO: set jtag speed to full speed
1052 svf_para
.frequency
= 0;
1056 if (strcmp(argus
[2], "HZ"))
1058 LOG_ERROR("HZ not found in FREQUENCY command");
1061 if (ERROR_OK
!= svf_execute_tap())
1065 svf_para
.frequency
= atof(argus
[1]);
1066 // TODO: set jtag speed to
1067 if (svf_para
.frequency
> 0)
1069 command_run_linef(cmd_ctx
, "adapter_khz %d", (int)svf_para
.frequency
/ 1000);
1070 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
1075 if (svf_tap_is_specified
)
1077 padding_command_skipped
= 1;
1080 xxr_para_tmp
= &svf_para
.hdr_para
;
1083 if (svf_tap_is_specified
)
1085 padding_command_skipped
= 1;
1088 xxr_para_tmp
= &svf_para
.hir_para
;
1091 if (svf_tap_is_specified
)
1093 padding_command_skipped
= 1;
1096 xxr_para_tmp
= &svf_para
.tdr_para
;
1099 if (svf_tap_is_specified
)
1101 padding_command_skipped
= 1;
1104 xxr_para_tmp
= &svf_para
.tir_para
;
1107 xxr_para_tmp
= &svf_para
.sdr_para
;
1110 xxr_para_tmp
= &svf_para
.sir_para
;
1113 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
1114 if ((num_of_argu
> 10) || (num_of_argu
% 2))
1116 LOG_ERROR("invalid parameter of %s", argus
[0]);
1119 i_tmp
= xxr_para_tmp
->len
;
1120 xxr_para_tmp
->len
= atoi(argus
[1]);
1121 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
1122 xxr_para_tmp
->data_mask
= 0;
1123 for (i
= 2; i
< num_of_argu
; i
+= 2)
1125 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
1127 LOG_ERROR("data section error");
1130 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
1131 // TDI, TDO, MASK, SMASK
1132 if (!strcmp(argus
[i
], "TDI"))
1135 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
1136 xxr_para_tmp
->data_mask
|= XXR_TDI
;
1138 else if (!strcmp(argus
[i
], "TDO"))
1141 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
1142 xxr_para_tmp
->data_mask
|= XXR_TDO
;
1144 else if (!strcmp(argus
[i
], "MASK"))
1147 pbuffer_tmp
= &xxr_para_tmp
->mask
;
1148 xxr_para_tmp
->data_mask
|= XXR_MASK
;
1150 else if (!strcmp(argus
[i
], "SMASK"))
1153 pbuffer_tmp
= &xxr_para_tmp
->smask
;
1154 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
1158 LOG_ERROR("unknow parameter: %s", argus
[i
]);
1161 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
1163 LOG_ERROR("fail to parse hex value");
1166 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & svf_get_mask_u32(xxr_para_tmp
->len
));
1168 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
1169 // the mask pattern used is all cares
1170 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
1172 // MASK not defined and length changed
1173 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
1175 LOG_ERROR("fail to adjust length of array");
1178 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
1180 // If TDO is absent, no comparison is needed, set the mask to 0
1181 if (!(xxr_para_tmp
->data_mask
& XXR_TDO
))
1183 if (NULL
== xxr_para_tmp
->tdo
)
1185 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->tdo
, i_tmp
, xxr_para_tmp
->len
))
1187 LOG_ERROR("fail to adjust length of array");
1191 if (NULL
== xxr_para_tmp
->mask
)
1193 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
1195 LOG_ERROR("fail to adjust length of array");
1199 memset(xxr_para_tmp
->mask
, 0, (xxr_para_tmp
->len
+ 7) >> 3);
1201 // do scan if necessary
1204 // check buffer size first, reallocate if necessary
1205 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
1206 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1209 // simply print error message
1210 LOG_ERROR("buffer is not enough, report to author");
1213 uint8_t *buffer_tmp
;
1215 // reallocate buffer
1216 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1217 if (NULL
== buffer_tmp
)
1219 LOG_ERROR("not enough memory");
1222 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1223 // svf_tdi_buffer isn't NULL here
1224 free(svf_tdi_buffer
);
1225 svf_tdi_buffer
= buffer_tmp
;
1227 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1228 if (NULL
== buffer_tmp
)
1230 LOG_ERROR("not enough memory");
1233 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1234 // svf_tdo_buffer isn't NULL here
1235 free(svf_tdo_buffer
);
1236 svf_tdo_buffer
= buffer_tmp
;
1238 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1239 if (NULL
== buffer_tmp
)
1241 LOG_ERROR("not enough memory");
1244 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1245 // svf_mask_buffer isn't NULL here
1246 free(svf_mask_buffer
);
1247 svf_mask_buffer
= buffer_tmp
;
1250 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1256 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1257 i
+= svf_para
.hdr_para
.len
;
1258 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1259 i
+= svf_para
.sdr_para
.len
;
1260 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1261 i
+= svf_para
.tdr_para
.len
;
1264 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
1266 // assemble dr mask data
1268 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1269 i
+= svf_para
.hdr_para
.len
;
1270 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1271 i
+= svf_para
.sdr_para
.len
;
1272 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1273 i
+= svf_para
.tdr_para
.len
;
1274 // assemble dr check data
1276 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1277 i
+= svf_para
.hdr_para
.len
;
1278 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1279 i
+= svf_para
.sdr_para
.len
;
1280 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1281 i
+= svf_para
.tdr_para
.len
;
1283 svf_add_check_para(1, svf_buffer_index
, i
);
1287 svf_add_check_para(0, svf_buffer_index
, i
);
1290 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1291 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1292 /* NOTE: doesn't use SVF-specified state paths */
1293 jtag_add_plain_dr_scan(field
.num_bits
, field
.out_value
, field
.in_value
, svf_para
.dr_end_state
);
1295 svf_buffer_index
+= (i
+ 7) >> 3;
1297 else if (SIR
== command
)
1299 // check buffer size first, reallocate if necessary
1300 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
1301 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1304 // simply print error message
1305 LOG_ERROR("buffer is not enough, report to author");
1308 uint8_t *buffer_tmp
;
1310 // reallocate buffer
1311 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1312 if (NULL
== buffer_tmp
)
1314 LOG_ERROR("not enough memory");
1317 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1318 // svf_tdi_buffer isn't NULL here
1319 free(svf_tdi_buffer
);
1320 svf_tdi_buffer
= buffer_tmp
;
1322 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1323 if (NULL
== buffer_tmp
)
1325 LOG_ERROR("not enough memory");
1328 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1329 // svf_tdo_buffer isn't NULL here
1330 free(svf_tdo_buffer
);
1331 svf_tdo_buffer
= buffer_tmp
;
1333 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1334 if (NULL
== buffer_tmp
)
1336 LOG_ERROR("not enough memory");
1339 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1340 // svf_mask_buffer isn't NULL here
1341 free(svf_mask_buffer
);
1342 svf_mask_buffer
= buffer_tmp
;
1345 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1351 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1352 i
+= svf_para
.hir_para
.len
;
1353 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1354 i
+= svf_para
.sir_para
.len
;
1355 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1356 i
+= svf_para
.tir_para
.len
;
1359 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1361 // assemble dr mask data
1363 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1364 i
+= svf_para
.hir_para
.len
;
1365 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1366 i
+= svf_para
.sir_para
.len
;
1367 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1368 i
+= svf_para
.tir_para
.len
;
1369 // assemble dr check data
1371 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1372 i
+= svf_para
.hir_para
.len
;
1373 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1374 i
+= svf_para
.sir_para
.len
;
1375 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1376 i
+= svf_para
.tir_para
.len
;
1378 svf_add_check_para(1, svf_buffer_index
, i
);
1382 svf_add_check_para(0, svf_buffer_index
, i
);
1385 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1386 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1387 /* NOTE: doesn't use SVF-specified state paths */
1388 jtag_add_plain_ir_scan(field
.num_bits
, field
.out_value
, field
.in_value
,
1389 svf_para
.ir_end_state
);
1391 svf_buffer_index
+= (i
+ 7) >> 3;
1396 LOG_ERROR("PIO and PIOMAP are not supported");
1400 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1401 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1402 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1404 LOG_ERROR("invalid parameter of %s", argus
[0]);
1414 i_tmp
= tap_state_by_name(argus
[i
]);
1415 if (i_tmp
!= TAP_INVALID
)
1417 if (svf_tap_state_is_stable(i_tmp
))
1419 svf_para
.runtest_run_state
= i_tmp
;
1421 /* When a run_state is specified, the new
1422 * run_state becomes the default end_state.
1424 svf_para
.runtest_end_state
= i_tmp
;
1425 LOG_DEBUG("\trun_state = %s",
1426 tap_state_name(i_tmp
));
1431 LOG_ERROR("%s: %s is not a stable state",
1432 argus
[0], tap_state_name(i_tmp
));
1437 // run_count run_clk
1438 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1440 if (!strcmp(argus
[i
+ 1], "TCK"))
1442 // clock source is TCK
1443 run_count
= atoi(argus
[i
]);
1444 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1448 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1454 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1456 min_time
= atof(argus
[i
]);
1457 LOG_DEBUG("\tmin_time = %fs", min_time
);
1460 // MAXIMUM max_time SEC
1461 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1463 max_time
= atof(argus
[i
+ 1]);
1464 LOG_DEBUG("\tmax_time = %fs", max_time
);
1467 // ENDSTATE end_state
1468 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1470 i_tmp
= tap_state_by_name(argus
[i
+ 1]);
1472 if (svf_tap_state_is_stable(i_tmp
))
1474 svf_para
.runtest_end_state
= i_tmp
;
1475 LOG_DEBUG("\tend_state = %s",
1476 tap_state_name(i_tmp
));
1480 LOG_ERROR("%s: %s is not a stable state",
1481 argus
[0], tap_state_name(i_tmp
));
1486 // calculate run_count
1487 if ((0 == run_count
) && (min_time
> 0))
1489 run_count
= min_time
* svf_para
.frequency
;
1491 // all parameter should be parsed
1492 if (i
== num_of_argu
)
1496 // run_state and end_state is checked to be stable state
1499 /* FIXME handle statemove failures */
1502 // enter into run_state if necessary
1503 if (cmd_queue_cur_state
!= svf_para
.runtest_run_state
)
1505 retval
= svf_add_statemove(svf_para
.runtest_run_state
);
1508 // call jtag_add_clocks
1509 jtag_add_clocks(run_count
);
1511 // move to end_state if necessary
1512 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1514 retval
= svf_add_statemove(svf_para
.runtest_end_state
);
1517 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1519 LOG_ERROR("cannot runtest in %s state",
1520 tap_state_name(svf_para
.runtest_run_state
));
1524 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1530 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1535 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1536 if (num_of_argu
< 2)
1538 LOG_ERROR("invalid parameter of %s", argus
[0]);
1541 if (num_of_argu
> 2)
1543 // STATE pathstate1 ... stable_state
1544 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1547 LOG_ERROR("not enough memory");
1550 num_of_argu
--; // num of path
1551 i_tmp
= 1; /* path is from parameter 1 */
1552 for (i
= 0; i
< num_of_argu
; i
++, i_tmp
++)
1554 path
[i
] = tap_state_by_name(argus
[i_tmp
]);
1555 if (path
[i
] == TAP_INVALID
)
1557 LOG_ERROR("%s: %s is not a valid state",
1558 argus
[0], argus
[i_tmp
]);
1562 /* OpenOCD refuses paths containing TAP_RESET */
1563 if (TAP_RESET
== path
[i
])
1565 /* FIXME last state MUST be stable! */
1568 jtag_add_pathmove(i
, path
);
1571 num_of_argu
-= i
+ 1;
1575 if (num_of_argu
> 0)
1577 // execute last path if necessary
1578 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1580 // last state MUST be stable state
1581 jtag_add_pathmove(num_of_argu
, path
);
1582 LOG_DEBUG("\tmove to %s by path_move",
1583 tap_state_name(path
[num_of_argu
- 1]));
1587 LOG_ERROR("%s: %s is not a stable state",
1589 tap_state_name(path
[num_of_argu
- 1]));
1600 // STATE stable_state
1601 state
= tap_state_by_name(argus
[1]);
1602 if (svf_tap_state_is_stable(state
))
1604 LOG_DEBUG("\tmove to %s by svf_add_statemove",
1605 tap_state_name(state
));
1606 /* FIXME handle statemove failures */
1607 svf_add_statemove(state
);
1611 LOG_ERROR("%s: %s is not a stable state",
1612 argus
[0], tap_state_name(state
));
1619 if (num_of_argu
!= 2)
1621 LOG_ERROR("invalid parameter of %s", argus
[0]);
1624 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1626 if (ERROR_OK
!= svf_execute_tap())
1630 i_tmp
= svf_find_string_in_array(argus
[1],
1631 (char **)svf_trst_mode_name
,
1632 ARRAY_SIZE(svf_trst_mode_name
));
1636 jtag_add_reset(1, 0);
1640 jtag_add_reset(0, 0);
1645 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1648 svf_para
.trst_mode
= i_tmp
;
1649 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1653 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1658 LOG_ERROR("invalid svf command: %s", argus
[0]);
1665 if (padding_command_skipped
)
1667 LOG_USER("(Above Padding command skipped, as per -tap argument)");
1671 if (debug_level
>= LOG_LVL_DEBUG
)
1673 // for convenient debugging, execute tap if possible
1674 if ((svf_buffer_index
> 0) && \
1675 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1676 ((command
== STATE
) && (num_of_argu
== 2))))
1678 if (ERROR_OK
!= svf_execute_tap())
1683 // output debug info
1684 if ((SIR
== command
) || (SDR
== command
))
1687 memcpy(&read_value
, svf_tdi_buffer
, sizeof(int));
1688 // in debug mode, data is from index 0
1689 int read_mask
= svf_get_mask_u32(svf_check_tdo_para
[0].bit_len
);
1690 LOG_DEBUG("\tTDO read = 0x%X", read_value
& read_mask
);
1696 // for fast executing, execute tap if necessary
1697 // half of the buffer is for the next command
1698 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1699 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1700 ((command
== STATE
) && (num_of_argu
== 2))))
1702 return svf_execute_tap();
1709 static const struct command_registration svf_command_handlers
[] = {
1712 .handler
= handle_svf_command
,
1713 .mode
= COMMAND_EXEC
,
1714 .help
= "Runs a SVF file.",
1717 COMMAND_REGISTRATION_DONE
1720 int svf_register_commands(struct command_context
*cmd_ctx
)
1722 return register_commands(cmd_ctx
, NULL
, svf_command_handlers
);
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)