1 /***************************************************************************
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 *
16 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
19 /* The specification for SVF is available here:
20 * http://www.asset-intertech.com/support/svf.pdf
21 * Below, this document is refered to as the "SVF spec".
23 * The specification for XSVF is available here:
24 * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
25 * Below, this document is refered to as the "XSVF spec".
32 #include <jtag/jtag.h>
34 #include <helper/time_support.h>
54 static const char *svf_command_name
[14] = {
78 static const char *svf_trst_mode_name
[4] = {
85 struct svf_statemove
{
88 uint32_t num_of_moves
;
93 * These paths are from the SVF specification for the STATE command, to be
94 * used when the STATE command only includes the final state. The first
95 * element of the path is the "from" (current) state, and the last one is
96 * the "to" (target) state.
98 * All specified paths are the shortest ones in the JTAG spec, and are thus
99 * not (!!) exact matches for the paths used elsewhere in OpenOCD. Note
100 * that PAUSE-to-PAUSE transitions all go through UPDATE and then CAPTURE,
101 * which has specific effects on the various registers; they are not NOPs.
103 * Paths to RESET are disabled here. As elsewhere in OpenOCD, and in XSVF
104 * and many SVF implementations, we don't want to risk missing that state.
105 * To get to RESET, always we ignore the current state.
107 static const struct svf_statemove svf_statemoves
[] = {
108 /* from to num_of_moves, paths[8] */
109 /* {TAP_RESET, TAP_RESET, 1, {TAP_RESET}}, */
110 {TAP_RESET
, TAP_IDLE
, 2, {TAP_RESET
, TAP_IDLE
} },
111 {TAP_RESET
, TAP_DRPAUSE
, 6, {TAP_RESET
, TAP_IDLE
, TAP_DRSELECT
,
112 TAP_DRCAPTURE
, TAP_DREXIT1
, TAP_DRPAUSE
} },
113 {TAP_RESET
, TAP_IRPAUSE
, 7, {TAP_RESET
, TAP_IDLE
, TAP_DRSELECT
,
114 TAP_IRSELECT
, TAP_IRCAPTURE
,
115 TAP_IREXIT1
, TAP_IRPAUSE
} },
117 /* {TAP_IDLE, TAP_RESET, 4, {TAP_IDLE,
118 * TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}}, */
119 {TAP_IDLE
, TAP_IDLE
, 1, {TAP_IDLE
} },
120 {TAP_IDLE
, TAP_DRPAUSE
, 5, {TAP_IDLE
, TAP_DRSELECT
, TAP_DRCAPTURE
,
121 TAP_DREXIT1
, TAP_DRPAUSE
} },
122 {TAP_IDLE
, TAP_IRPAUSE
, 6, {TAP_IDLE
, TAP_DRSELECT
, TAP_IRSELECT
,
123 TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
} },
125 /* {TAP_DRPAUSE, TAP_RESET, 6, {TAP_DRPAUSE,
126 * TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}}, */
127 {TAP_DRPAUSE
, TAP_IDLE
, 4, {TAP_DRPAUSE
, TAP_DREXIT2
, TAP_DRUPDATE
,
129 {TAP_DRPAUSE
, TAP_DRPAUSE
, 7, {TAP_DRPAUSE
, TAP_DREXIT2
, TAP_DRUPDATE
,
130 TAP_DRSELECT
, TAP_DRCAPTURE
,
131 TAP_DREXIT1
, TAP_DRPAUSE
} },
132 {TAP_DRPAUSE
, TAP_IRPAUSE
, 8, {TAP_DRPAUSE
, TAP_DREXIT2
, TAP_DRUPDATE
,
133 TAP_DRSELECT
, TAP_IRSELECT
,
134 TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
} },
136 /* {TAP_IRPAUSE, TAP_RESET, 6, {TAP_IRPAUSE,
137 * TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}}, */
138 {TAP_IRPAUSE
, TAP_IDLE
, 4, {TAP_IRPAUSE
, TAP_IREXIT2
, TAP_IRUPDATE
,
140 {TAP_IRPAUSE
, TAP_DRPAUSE
, 7, {TAP_IRPAUSE
, TAP_IREXIT2
, TAP_IRUPDATE
,
141 TAP_DRSELECT
, TAP_DRCAPTURE
,
142 TAP_DREXIT1
, TAP_DRPAUSE
} },
143 {TAP_IRPAUSE
, TAP_IRPAUSE
, 8, {TAP_IRPAUSE
, TAP_IREXIT2
, TAP_IRUPDATE
,
144 TAP_DRSELECT
, TAP_IRSELECT
,
145 TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
} }
148 #define XXR_TDI (1 << 0)
149 #define XXR_TDO (1 << 1)
150 #define XXR_MASK (1 << 2)
151 #define XXR_SMASK (1 << 3)
152 struct svf_xxr_para
{
163 tap_state_t ir_end_state
;
164 tap_state_t dr_end_state
;
165 tap_state_t runtest_run_state
;
166 tap_state_t runtest_end_state
;
167 enum trst_mode trst_mode
;
169 struct svf_xxr_para hir_para
;
170 struct svf_xxr_para hdr_para
;
171 struct svf_xxr_para tir_para
;
172 struct svf_xxr_para tdr_para
;
173 struct svf_xxr_para sir_para
;
174 struct svf_xxr_para sdr_para
;
177 static struct svf_para svf_para
;
178 static const struct svf_para svf_para_init
= {
179 /* frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode */
180 0, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TRST_Z
,
182 /* {len, data_mask, tdi, tdo, mask, smask}, */
183 {0, 0, NULL
, NULL
, NULL
, NULL
},
185 /* {len, data_mask, tdi, tdo, mask, smask}, */
186 {0, 0, NULL
, NULL
, NULL
, NULL
},
188 /* {len, data_mask, tdi, tdo, mask, smask}, */
189 {0, 0, NULL
, NULL
, NULL
, NULL
},
191 /* {len, data_mask, tdi, tdo, mask, smask}, */
192 {0, 0, NULL
, NULL
, NULL
, NULL
},
194 /* {len, data_mask, tdi, tdo, mask, smask}, */
195 {0, 0, NULL
, NULL
, NULL
, NULL
},
197 /* {len, data_mask, tdi, tdo, mask, smask}, */
198 {0, 0, NULL
, NULL
, NULL
, NULL
},
201 struct svf_check_tdo_para
{
202 int line_num
; /* used to record line number of the check operation */
203 /* so more information could be printed */
204 int enabled
; /* check is enabled or not */
205 int buffer_offset
; /* buffer_offset to buffers */
206 int bit_len
; /* bit length to check */
209 #define SVF_CHECK_TDO_PARA_SIZE 1024
210 static struct svf_check_tdo_para
*svf_check_tdo_para
;
211 static int svf_check_tdo_para_index
;
213 static int svf_read_command_from_file(FILE *fd
);
214 static int svf_check_tdo(void);
215 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
);
216 static int svf_run_command(struct command_context
*cmd_ctx
, char *cmd_str
);
217 static int svf_execute_tap(void);
220 static char *svf_read_line
;
221 static size_t svf_read_line_size
;
222 static char *svf_command_buffer
;
223 static size_t svf_command_buffer_size
;
224 static int svf_line_number
;
225 static int svf_getline(char **lineptr
, size_t *n
, FILE *stream
);
227 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (1024 * 1024)
228 static uint8_t *svf_tdi_buffer
, *svf_tdo_buffer
, *svf_mask_buffer
;
229 static int svf_buffer_index
, svf_buffer_size
;
230 static int svf_quiet
;
232 static int svf_ignore_error
;
234 /* Targetting particular tap */
235 static int svf_tap_is_specified
;
236 static int svf_set_padding(struct svf_xxr_para
*para
, int len
, unsigned char tdi
);
238 /* Progress Indicator */
239 static int svf_progress_enabled
;
240 static long svf_total_lines
;
241 static int svf_percentage
;
242 static int svf_last_printed_percentage
= -1;
245 * macro is used to print the svf hex buffer at desired debug level
246 * DEBUG, INFO, ERROR, USER
248 #define SVF_BUF_LOG(_lvl, _buf, _nbits, _desc) \
249 svf_hexbuf_print(LOG_LVL_##_lvl , __FILE__, __LINE__, __func__, _buf, _nbits, _desc)
251 static void svf_hexbuf_print(int dbg_lvl
, const char *file
, unsigned line
,
252 const char *function
, const uint8_t *buf
,
253 int bit_len
, const char *desc
)
256 int byte_len
= DIV_ROUND_UP(bit_len
, 8);
257 int msbits
= bit_len
% 8;
259 /* allocate 2 bytes per hex digit */
260 char *prbuf
= malloc((byte_len
* 2) + 2 + 1);
264 /* print correct number of bytes, mask excess bits where applicable */
265 uint8_t msb
= buf
[byte_len
- 1] & (msbits
? (1 << msbits
) - 1 : 0xff);
266 len
= sprintf(prbuf
, msbits
<= 4 ? "0x%01"PRIx8
: "0x%02"PRIx8
, msb
);
267 for (j
= byte_len
- 2; j
>= 0; j
--)
268 len
+= sprintf(prbuf
+ len
, "%02"PRIx8
, buf
[j
]);
270 log_printf_lf(dbg_lvl
, file
, line
, function
, "%8s = %s", desc
? desc
: " ", prbuf
);
275 static int svf_realloc_buffers(size_t len
)
279 if (svf_execute_tap() != ERROR_OK
)
282 ptr
= realloc(svf_tdi_buffer
, len
);
285 svf_tdi_buffer
= ptr
;
287 ptr
= realloc(svf_tdo_buffer
, len
);
290 svf_tdo_buffer
= ptr
;
292 ptr
= realloc(svf_mask_buffer
, len
);
295 svf_mask_buffer
= ptr
;
297 svf_buffer_size
= len
;
302 static void svf_free_xxd_para(struct svf_xxr_para
*para
)
305 if (para
->tdi
!= NULL
) {
309 if (para
->tdo
!= NULL
) {
313 if (para
->mask
!= NULL
) {
317 if (para
->smask
!= NULL
) {
324 int svf_add_statemove(tap_state_t state_to
)
326 tap_state_t state_from
= cmd_queue_cur_state
;
329 /* when resetting, be paranoid and ignore current state */
330 if (state_to
== TAP_RESET
) {
338 for (index_var
= 0; index_var
< ARRAY_SIZE(svf_statemoves
); index_var
++) {
339 if ((svf_statemoves
[index_var
].from
== state_from
)
340 && (svf_statemoves
[index_var
].to
== state_to
)) {
343 /* recorded path includes current state ... avoid
345 if (svf_statemoves
[index_var
].num_of_moves
> 1)
346 jtag_add_pathmove(svf_statemoves
[index_var
].num_of_moves
- 1,
347 svf_statemoves
[index_var
].paths
+ 1);
349 jtag_add_pathmove(svf_statemoves
[index_var
].num_of_moves
,
350 svf_statemoves
[index_var
].paths
);
354 LOG_ERROR("SVF: can not move to %s", tap_state_name(state_to
));
358 COMMAND_HANDLER(handle_svf_command
)
360 #define SVF_MIN_NUM_OF_OPTIONS 1
361 #define SVF_MAX_NUM_OF_OPTIONS 5
364 int64_t time_measure_ms
;
365 int time_measure_s
, time_measure_m
;
367 /* use NULL to indicate a "plain" svf file which accounts for
368 * any additional devices in the scan chain, otherwise the device
369 * that should be affected
371 struct jtag_tap
*tap
= NULL
;
373 if ((CMD_ARGC
< SVF_MIN_NUM_OF_OPTIONS
) || (CMD_ARGC
> SVF_MAX_NUM_OF_OPTIONS
))
374 return ERROR_COMMAND_SYNTAX_ERROR
;
376 /* parse command line */
379 svf_progress_enabled
= 0;
380 svf_ignore_error
= 0;
381 for (unsigned int i
= 0; i
< CMD_ARGC
; i
++) {
382 if (strcmp(CMD_ARGV
[i
], "-tap") == 0) {
383 tap
= jtag_tap_by_string(CMD_ARGV
[i
+1]);
385 command_print(CMD_CTX
, "Tap: %s unknown", CMD_ARGV
[i
+1]);
389 } else if ((strcmp(CMD_ARGV
[i
],
390 "quiet") == 0) || (strcmp(CMD_ARGV
[i
], "-quiet") == 0))
392 else if ((strcmp(CMD_ARGV
[i
], "nil") == 0) || (strcmp(CMD_ARGV
[i
], "-nil") == 0))
394 else if ((strcmp(CMD_ARGV
[i
],
395 "progress") == 0) || (strcmp(CMD_ARGV
[i
], "-progress") == 0))
396 svf_progress_enabled
= 1;
397 else if ((strcmp(CMD_ARGV
[i
],
398 "ignore_error") == 0) || (strcmp(CMD_ARGV
[i
], "-ignore_error") == 0))
399 svf_ignore_error
= 1;
401 svf_fd
= fopen(CMD_ARGV
[i
], "r");
402 if (svf_fd
== NULL
) {
404 command_print(CMD_CTX
, "open(\"%s\"): %s", CMD_ARGV
[i
], strerror(err
));
405 /* no need to free anything now */
406 return ERROR_COMMAND_SYNTAX_ERROR
;
408 LOG_USER("svf processing file: \"%s\"", CMD_ARGV
[i
]);
413 return ERROR_COMMAND_SYNTAX_ERROR
;
416 time_measure_ms
= timeval_ms();
420 svf_command_buffer_size
= 0;
422 svf_check_tdo_para_index
= 0;
423 svf_check_tdo_para
= malloc(sizeof(struct svf_check_tdo_para
) * SVF_CHECK_TDO_PARA_SIZE
);
424 if (NULL
== svf_check_tdo_para
) {
425 LOG_ERROR("not enough memory");
430 svf_buffer_index
= 0;
431 /* double the buffer size */
432 /* in case current command cannot be committed, and next command is a bit scan command */
433 /* here is 32K bits for this big scan command, it should be enough */
434 /* buffer will be reallocated if buffer size is not enough */
435 if (svf_realloc_buffers(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
) != ERROR_OK
) {
440 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
448 /* Tap is specified, set header/trailer paddings */
449 int header_ir_len
= 0, header_dr_len
= 0, trailer_ir_len
= 0, trailer_dr_len
= 0;
450 struct jtag_tap
*check_tap
;
452 svf_tap_is_specified
= 1;
454 for (check_tap
= jtag_all_taps(); check_tap
; check_tap
= check_tap
->next_tap
) {
455 if (check_tap
->abs_chain_position
< tap
->abs_chain_position
) {
457 header_ir_len
+= check_tap
->ir_length
;
459 } else if (check_tap
->abs_chain_position
> tap
->abs_chain_position
) {
461 trailer_ir_len
+= check_tap
->ir_length
;
467 if (ERROR_OK
!= svf_set_padding(&svf_para
.hdr_para
, header_dr_len
, 0)) {
468 LOG_ERROR("failed to set data header");
472 /* HIR %d TDI (0xFF) */
473 if (ERROR_OK
!= svf_set_padding(&svf_para
.hir_para
, header_ir_len
, 0xFF)) {
474 LOG_ERROR("failed to set instruction header");
479 if (ERROR_OK
!= svf_set_padding(&svf_para
.tdr_para
, trailer_dr_len
, 0)) {
480 LOG_ERROR("failed to set data trailer");
484 /* TIR %d TDI (0xFF) */
485 if (ERROR_OK
!= svf_set_padding(&svf_para
.tir_para
, trailer_ir_len
, 0xFF)) {
486 LOG_ERROR("failed to set instruction trailer");
491 if (svf_progress_enabled
) {
492 /* Count total lines in file. */
493 while (!feof(svf_fd
)) {
494 svf_getline(&svf_command_buffer
, &svf_command_buffer_size
, svf_fd
);
499 while (ERROR_OK
== svf_read_command_from_file(svf_fd
)) {
502 if (svf_progress_enabled
) {
503 svf_percentage
= ((svf_line_number
* 20) / svf_total_lines
) * 5;
504 if (svf_last_printed_percentage
!= svf_percentage
) {
505 LOG_USER_N("\r%d%% ", svf_percentage
);
506 svf_last_printed_percentage
= svf_percentage
;
510 if (svf_progress_enabled
) {
511 svf_percentage
= ((svf_line_number
* 20) / svf_total_lines
) * 5;
512 LOG_USER_N("%3d%% %s", svf_percentage
, svf_read_line
);
514 LOG_USER_N("%s", svf_read_line
);
517 if (ERROR_OK
!= svf_run_command(CMD_CTX
, svf_command_buffer
)) {
518 LOG_ERROR("fail to run command at line %d", svf_line_number
);
525 if ((!svf_nil
) && (ERROR_OK
!= jtag_execute_queue()))
527 else if (ERROR_OK
!= svf_check_tdo())
531 time_measure_ms
= timeval_ms() - time_measure_ms
;
532 time_measure_s
= time_measure_ms
/ 1000;
533 time_measure_ms
%= 1000;
534 time_measure_m
= time_measure_s
/ 60;
535 time_measure_s
%= 60;
536 if (time_measure_ms
< 1000)
537 command_print(CMD_CTX
,
538 "\r\nTime used: %dm%ds%" PRId64
"ms ",
549 if (svf_command_buffer
) {
550 free(svf_command_buffer
);
551 svf_command_buffer
= NULL
;
552 svf_command_buffer_size
= 0;
554 if (svf_check_tdo_para
) {
555 free(svf_check_tdo_para
);
556 svf_check_tdo_para
= NULL
;
557 svf_check_tdo_para_index
= 0;
559 if (svf_tdi_buffer
) {
560 free(svf_tdi_buffer
);
561 svf_tdi_buffer
= NULL
;
563 if (svf_tdo_buffer
) {
564 free(svf_tdo_buffer
);
565 svf_tdo_buffer
= NULL
;
567 if (svf_mask_buffer
) {
568 free(svf_mask_buffer
);
569 svf_mask_buffer
= NULL
;
571 svf_buffer_index
= 0;
574 svf_free_xxd_para(&svf_para
.hdr_para
);
575 svf_free_xxd_para(&svf_para
.hir_para
);
576 svf_free_xxd_para(&svf_para
.tdr_para
);
577 svf_free_xxd_para(&svf_para
.tir_para
);
578 svf_free_xxd_para(&svf_para
.sdr_para
);
579 svf_free_xxd_para(&svf_para
.sir_para
);
582 command_print(CMD_CTX
,
583 "svf file programmed %s for %d commands with %d errors",
584 (svf_ignore_error
> 1) ? "unsuccessfully" : "successfully",
586 (svf_ignore_error
> 1) ? (svf_ignore_error
- 1) : 0);
588 command_print(CMD_CTX
, "svf file programmed failed");
590 svf_ignore_error
= 0;
594 static int svf_getline(char **lineptr
, size_t *n
, FILE *stream
)
596 #define MIN_CHUNK 16 /* Buffer is increased by this size each time as required */
599 if (*lineptr
== NULL
) {
601 *lineptr
= malloc(*n
);
606 (*lineptr
)[0] = fgetc(stream
);
607 while ((*lineptr
)[i
] != '\n') {
608 (*lineptr
)[++i
] = fgetc(stream
);
615 *lineptr
= realloc(*lineptr
, *n
);
621 return sizeof(*lineptr
);
624 #define SVFP_CMD_INC_CNT 1024
625 static int svf_read_command_from_file(FILE *fd
)
630 int cmd_ok
= 0, slash
= 0;
632 if (svf_getline(&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
635 ch
= svf_read_line
[0];
636 while (!cmd_ok
&& (ch
!= 0)) {
640 if (svf_getline(&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
648 if (svf_getline(&svf_read_line
, &svf_read_line_size
,
661 if (svf_getline(&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
666 /* Don't save '\r' and '\n' if no data is parsed */
670 /* The parsing code currently expects a space
671 * before parentheses -- "TDI (123)". Also a
672 * space afterwards -- "TDI (123) TDO(456)".
673 * But such spaces are optional... instead of
674 * parser updates, cope with that by adding the
677 * Ensure there are 3 bytes available, for:
678 * - current character
680 * - terminating NUL ('\0')
682 if (cmd_pos
+ 3 > svf_command_buffer_size
) {
683 svf_command_buffer
= realloc(svf_command_buffer
, cmd_pos
+ 3);
684 svf_command_buffer_size
= cmd_pos
+ 3;
685 if (svf_command_buffer
== NULL
) {
686 LOG_ERROR("not enough memory");
691 /* insert a space before '(' */
693 svf_command_buffer
[cmd_pos
++] = ' ';
695 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
697 /* insert a space after ')' */
699 svf_command_buffer
[cmd_pos
++] = ' ';
702 ch
= svf_read_line
[++i
];
706 svf_command_buffer
[cmd_pos
] = '\0';
712 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
714 int pos
= 0, num
= 0, space_found
= 1, in_bracket
= 0;
720 LOG_ERROR("fail to parse svf command");
730 if (!in_bracket
&& isspace((int) str
[pos
])) {
733 } else if (space_found
) {
734 argus
[num
++] = &str
[pos
];
747 bool svf_tap_state_is_stable(tap_state_t state
)
749 return (TAP_RESET
== state
) || (TAP_IDLE
== state
)
750 || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
);
753 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
757 for (i
= 0; i
< num_of_element
; i
++) {
758 if (!strcmp(str
, strs
[i
]))
764 static int svf_adjust_array_length(uint8_t **arr
, int orig_bit_len
, int new_bit_len
)
766 int new_byte_len
= (new_bit_len
+ 7) >> 3;
768 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3))) {
773 *arr
= malloc(new_byte_len
);
775 LOG_ERROR("not enough memory");
778 memset(*arr
, 0, new_byte_len
);
783 static int svf_set_padding(struct svf_xxr_para
*para
, int len
, unsigned char tdi
)
785 int error
= ERROR_OK
;
786 error
|= svf_adjust_array_length(¶
->tdi
, para
->len
, len
);
787 memset(para
->tdi
, tdi
, (len
+ 7) >> 3);
788 error
|= svf_adjust_array_length(¶
->tdo
, para
->len
, len
);
789 error
|= svf_adjust_array_length(¶
->mask
, para
->len
, len
);
791 para
->data_mask
= XXR_TDI
;
796 static int svf_copy_hexstring_to_binary(char *str
, uint8_t **bin
, int orig_bit_len
, int bit_len
)
798 int i
, str_len
= strlen(str
), str_hbyte_len
= (bit_len
+ 3) >> 2;
801 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
)) {
802 LOG_ERROR("fail to adjust length of array");
806 /* fill from LSB (end of str) to MSB (beginning of str) */
807 for (i
= 0; i
< str_hbyte_len
; i
++) {
809 while (str_len
> 0) {
812 /* Skip whitespace. The SVF specification (rev E) is
813 * deficient in terms of basic lexical issues like
814 * where whitespace is allowed. Long bitstrings may
815 * require line ends for correctness, since there is
816 * a hard limit on line length.
819 if ((ch
>= '0') && (ch
<= '9')) {
822 } else if ((ch
>= 'A') && (ch
<= 'F')) {
826 LOG_ERROR("invalid hex string");
837 (*bin
)[i
/ 2] |= ch
<< 4;
845 /* consume optional leading '0' MSBs or whitespace */
846 while (str_len
> 0 && ((str
[str_len
- 1] == '0')
847 || isspace((int) str
[str_len
- 1])))
850 /* check validity: we must have consumed everything */
851 if (str_len
> 0 || (ch
& ~((2 << ((bit_len
- 1) % 4)) - 1)) != 0) {
852 LOG_ERROR("value execeeds length");
859 static int svf_check_tdo(void)
861 int i
, len
, index_var
;
863 for (i
= 0; i
< svf_check_tdo_para_index
; i
++) {
864 index_var
= svf_check_tdo_para
[i
].buffer_offset
;
865 len
= svf_check_tdo_para
[i
].bit_len
;
866 if ((svf_check_tdo_para
[i
].enabled
)
867 && buf_cmp_mask(&svf_tdi_buffer
[index_var
], &svf_tdo_buffer
[index_var
],
868 &svf_mask_buffer
[index_var
], len
)) {
869 LOG_ERROR("tdo check error at line %d",
870 svf_check_tdo_para
[i
].line_num
);
871 SVF_BUF_LOG(ERROR
, &svf_tdi_buffer
[index_var
], len
, "READ");
872 SVF_BUF_LOG(ERROR
, &svf_tdo_buffer
[index_var
], len
, "WANT");
873 SVF_BUF_LOG(ERROR
, &svf_mask_buffer
[index_var
], len
, "MASK");
875 if (svf_ignore_error
== 0)
881 svf_check_tdo_para_index
= 0;
886 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
)
888 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
) {
889 LOG_ERROR("toooooo many operation undone");
893 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
894 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
895 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
896 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
897 svf_check_tdo_para_index
++;
902 static int svf_execute_tap(void)
904 if ((!svf_nil
) && (ERROR_OK
!= jtag_execute_queue()))
906 else if (ERROR_OK
!= svf_check_tdo())
909 svf_buffer_index
= 0;
914 static int svf_run_command(struct command_context
*cmd_ctx
, char *cmd_str
)
916 char *argus
[256], command
;
917 int num_of_argu
= 0, i
;
926 struct svf_xxr_para
*xxr_para_tmp
;
927 uint8_t **pbuffer_tmp
;
928 struct scan_field field
;
930 tap_state_t
*path
= NULL
, state
;
931 /* flag padding commands skipped due to -tap command */
932 int padding_command_skipped
= 0;
934 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
937 /* NOTE: we're a bit loose here, because we ignore case in
938 * TAP state names (instead of insisting on uppercase).
941 command
= svf_find_string_in_array(argus
[0],
942 (char **)svf_command_name
, ARRAY_SIZE(svf_command_name
));
946 if (num_of_argu
!= 2) {
947 LOG_ERROR("invalid parameter of %s", argus
[0]);
951 i_tmp
= tap_state_by_name(argus
[1]);
953 if (svf_tap_state_is_stable(i_tmp
)) {
954 if (command
== ENDIR
) {
955 svf_para
.ir_end_state
= i_tmp
;
956 LOG_DEBUG("\tIR end_state = %s",
957 tap_state_name(i_tmp
));
959 svf_para
.dr_end_state
= i_tmp
;
960 LOG_DEBUG("\tDR end_state = %s",
961 tap_state_name(i_tmp
));
964 LOG_ERROR("%s: %s is not a stable state",
970 if ((num_of_argu
!= 1) && (num_of_argu
!= 3)) {
971 LOG_ERROR("invalid parameter of %s", argus
[0]);
974 if (1 == num_of_argu
) {
975 /* TODO: set jtag speed to full speed */
976 svf_para
.frequency
= 0;
978 if (strcmp(argus
[2], "HZ")) {
979 LOG_ERROR("HZ not found in FREQUENCY command");
982 if (ERROR_OK
!= svf_execute_tap())
984 svf_para
.frequency
= atof(argus
[1]);
985 /* TODO: set jtag speed to */
986 if (svf_para
.frequency
> 0) {
987 command_run_linef(cmd_ctx
,
989 (int)svf_para
.frequency
/ 1000);
990 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
995 if (svf_tap_is_specified
) {
996 padding_command_skipped
= 1;
999 xxr_para_tmp
= &svf_para
.hdr_para
;
1002 if (svf_tap_is_specified
) {
1003 padding_command_skipped
= 1;
1006 xxr_para_tmp
= &svf_para
.hir_para
;
1009 if (svf_tap_is_specified
) {
1010 padding_command_skipped
= 1;
1013 xxr_para_tmp
= &svf_para
.tdr_para
;
1016 if (svf_tap_is_specified
) {
1017 padding_command_skipped
= 1;
1020 xxr_para_tmp
= &svf_para
.tir_para
;
1023 xxr_para_tmp
= &svf_para
.sdr_para
;
1026 xxr_para_tmp
= &svf_para
.sir_para
;
1029 /* XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)] */
1030 if ((num_of_argu
> 10) || (num_of_argu
% 2)) {
1031 LOG_ERROR("invalid parameter of %s", argus
[0]);
1034 i_tmp
= xxr_para_tmp
->len
;
1035 xxr_para_tmp
->len
= atoi(argus
[1]);
1036 /* If we are to enlarge the buffers, all parts of xxr_para_tmp
1037 * need to be freed */
1038 if (i_tmp
< xxr_para_tmp
->len
) {
1039 free(xxr_para_tmp
->tdi
);
1040 xxr_para_tmp
->tdi
= NULL
;
1041 free(xxr_para_tmp
->tdo
);
1042 xxr_para_tmp
->tdo
= NULL
;
1043 free(xxr_para_tmp
->mask
);
1044 xxr_para_tmp
->mask
= NULL
;
1045 free(xxr_para_tmp
->smask
);
1046 xxr_para_tmp
->smask
= NULL
;
1049 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
1050 xxr_para_tmp
->data_mask
= 0;
1051 for (i
= 2; i
< num_of_argu
; i
+= 2) {
1052 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') ||
1053 (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')')) {
1054 LOG_ERROR("data section error");
1057 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
1058 /* TDI, TDO, MASK, SMASK */
1059 if (!strcmp(argus
[i
], "TDI")) {
1061 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
1062 xxr_para_tmp
->data_mask
|= XXR_TDI
;
1063 } else if (!strcmp(argus
[i
], "TDO")) {
1065 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
1066 xxr_para_tmp
->data_mask
|= XXR_TDO
;
1067 } else if (!strcmp(argus
[i
], "MASK")) {
1069 pbuffer_tmp
= &xxr_para_tmp
->mask
;
1070 xxr_para_tmp
->data_mask
|= XXR_MASK
;
1071 } else if (!strcmp(argus
[i
], "SMASK")) {
1073 pbuffer_tmp
= &xxr_para_tmp
->smask
;
1074 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
1076 LOG_ERROR("unknow parameter: %s", argus
[i
]);
1080 svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
,
1081 xxr_para_tmp
->len
)) {
1082 LOG_ERROR("fail to parse hex value");
1085 SVF_BUF_LOG(DEBUG
, *pbuffer_tmp
, xxr_para_tmp
->len
, argus
[i
]);
1087 /* If a command changes the length of the last scan of the same type and the
1088 * MASK parameter is absent, */
1089 /* the mask pattern used is all cares */
1090 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
)) {
1091 /* MASK not defined and length changed */
1093 svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
,
1094 xxr_para_tmp
->len
)) {
1095 LOG_ERROR("fail to adjust length of array");
1098 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
1100 /* If TDO is absent, no comparison is needed, set the mask to 0 */
1101 if (!(xxr_para_tmp
->data_mask
& XXR_TDO
)) {
1102 if (NULL
== xxr_para_tmp
->tdo
) {
1104 svf_adjust_array_length(&xxr_para_tmp
->tdo
, i_tmp
,
1105 xxr_para_tmp
->len
)) {
1106 LOG_ERROR("fail to adjust length of array");
1110 if (NULL
== xxr_para_tmp
->mask
) {
1112 svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
,
1113 xxr_para_tmp
->len
)) {
1114 LOG_ERROR("fail to adjust length of array");
1118 memset(xxr_para_tmp
->mask
, 0, (xxr_para_tmp
->len
+ 7) >> 3);
1120 /* do scan if necessary */
1121 if (SDR
== command
) {
1122 /* check buffer size first, reallocate if necessary */
1123 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+
1124 svf_para
.tdr_para
.len
;
1125 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3)) {
1126 /* reallocate buffer */
1127 if (svf_realloc_buffers(svf_buffer_index
+ ((i
+ 7) >> 3)) != ERROR_OK
) {
1128 LOG_ERROR("not enough memory");
1133 /* assemble dr data */
1135 buf_set_buf(svf_para
.hdr_para
.tdi
,
1137 &svf_tdi_buffer
[svf_buffer_index
],
1139 svf_para
.hdr_para
.len
);
1140 i
+= svf_para
.hdr_para
.len
;
1141 buf_set_buf(svf_para
.sdr_para
.tdi
,
1143 &svf_tdi_buffer
[svf_buffer_index
],
1145 svf_para
.sdr_para
.len
);
1146 i
+= svf_para
.sdr_para
.len
;
1147 buf_set_buf(svf_para
.tdr_para
.tdi
,
1149 &svf_tdi_buffer
[svf_buffer_index
],
1151 svf_para
.tdr_para
.len
);
1152 i
+= svf_para
.tdr_para
.len
;
1154 /* add check data */
1155 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
) {
1156 /* assemble dr mask data */
1158 buf_set_buf(svf_para
.hdr_para
.mask
,
1160 &svf_mask_buffer
[svf_buffer_index
],
1162 svf_para
.hdr_para
.len
);
1163 i
+= svf_para
.hdr_para
.len
;
1164 buf_set_buf(svf_para
.sdr_para
.mask
,
1166 &svf_mask_buffer
[svf_buffer_index
],
1168 svf_para
.sdr_para
.len
);
1169 i
+= svf_para
.sdr_para
.len
;
1170 buf_set_buf(svf_para
.tdr_para
.mask
,
1172 &svf_mask_buffer
[svf_buffer_index
],
1174 svf_para
.tdr_para
.len
);
1176 /* assemble dr check data */
1178 buf_set_buf(svf_para
.hdr_para
.tdo
,
1180 &svf_tdo_buffer
[svf_buffer_index
],
1182 svf_para
.hdr_para
.len
);
1183 i
+= svf_para
.hdr_para
.len
;
1184 buf_set_buf(svf_para
.sdr_para
.tdo
,
1186 &svf_tdo_buffer
[svf_buffer_index
],
1188 svf_para
.sdr_para
.len
);
1189 i
+= svf_para
.sdr_para
.len
;
1190 buf_set_buf(svf_para
.tdr_para
.tdo
,
1192 &svf_tdo_buffer
[svf_buffer_index
],
1194 svf_para
.tdr_para
.len
);
1195 i
+= svf_para
.tdr_para
.len
;
1197 svf_add_check_para(1, svf_buffer_index
, i
);
1199 svf_add_check_para(0, svf_buffer_index
, i
);
1201 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1202 field
.in_value
= (xxr_para_tmp
->data_mask
& XXR_TDO
) ? &svf_tdi_buffer
[svf_buffer_index
] : NULL
;
1204 /* NOTE: doesn't use SVF-specified state paths */
1205 jtag_add_plain_dr_scan(field
.num_bits
,
1208 svf_para
.dr_end_state
);
1211 svf_buffer_index
+= (i
+ 7) >> 3;
1212 } else if (SIR
== command
) {
1213 /* check buffer size first, reallocate if necessary */
1214 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+
1215 svf_para
.tir_para
.len
;
1216 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3)) {
1217 if (svf_realloc_buffers(svf_buffer_index
+ ((i
+ 7) >> 3)) != ERROR_OK
) {
1218 LOG_ERROR("not enough memory");
1223 /* assemble ir data */
1225 buf_set_buf(svf_para
.hir_para
.tdi
,
1227 &svf_tdi_buffer
[svf_buffer_index
],
1229 svf_para
.hir_para
.len
);
1230 i
+= svf_para
.hir_para
.len
;
1231 buf_set_buf(svf_para
.sir_para
.tdi
,
1233 &svf_tdi_buffer
[svf_buffer_index
],
1235 svf_para
.sir_para
.len
);
1236 i
+= svf_para
.sir_para
.len
;
1237 buf_set_buf(svf_para
.tir_para
.tdi
,
1239 &svf_tdi_buffer
[svf_buffer_index
],
1241 svf_para
.tir_para
.len
);
1242 i
+= svf_para
.tir_para
.len
;
1244 /* add check data */
1245 if (svf_para
.sir_para
.data_mask
& XXR_TDO
) {
1246 /* assemble dr mask data */
1248 buf_set_buf(svf_para
.hir_para
.mask
,
1250 &svf_mask_buffer
[svf_buffer_index
],
1252 svf_para
.hir_para
.len
);
1253 i
+= svf_para
.hir_para
.len
;
1254 buf_set_buf(svf_para
.sir_para
.mask
,
1256 &svf_mask_buffer
[svf_buffer_index
],
1258 svf_para
.sir_para
.len
);
1259 i
+= svf_para
.sir_para
.len
;
1260 buf_set_buf(svf_para
.tir_para
.mask
,
1262 &svf_mask_buffer
[svf_buffer_index
],
1264 svf_para
.tir_para
.len
);
1266 /* assemble dr check data */
1268 buf_set_buf(svf_para
.hir_para
.tdo
,
1270 &svf_tdo_buffer
[svf_buffer_index
],
1272 svf_para
.hir_para
.len
);
1273 i
+= svf_para
.hir_para
.len
;
1274 buf_set_buf(svf_para
.sir_para
.tdo
,
1276 &svf_tdo_buffer
[svf_buffer_index
],
1278 svf_para
.sir_para
.len
);
1279 i
+= svf_para
.sir_para
.len
;
1280 buf_set_buf(svf_para
.tir_para
.tdo
,
1282 &svf_tdo_buffer
[svf_buffer_index
],
1284 svf_para
.tir_para
.len
);
1285 i
+= svf_para
.tir_para
.len
;
1287 svf_add_check_para(1, svf_buffer_index
, i
);
1289 svf_add_check_para(0, svf_buffer_index
, i
);
1291 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1292 field
.in_value
= (xxr_para_tmp
->data_mask
& XXR_TDO
) ? &svf_tdi_buffer
[svf_buffer_index
] : NULL
;
1294 /* NOTE: doesn't use SVF-specified state paths */
1295 jtag_add_plain_ir_scan(field
.num_bits
,
1298 svf_para
.ir_end_state
);
1301 svf_buffer_index
+= (i
+ 7) >> 3;
1306 LOG_ERROR("PIO and PIOMAP are not supported");
1310 /* RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time
1311 * SEC]] [ENDSTATE end_state] */
1312 /* RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE
1314 if ((num_of_argu
< 3) && (num_of_argu
> 11)) {
1315 LOG_ERROR("invalid parameter of %s", argus
[0]);
1324 i_tmp
= tap_state_by_name(argus
[i
]);
1325 if (i_tmp
!= TAP_INVALID
) {
1326 if (svf_tap_state_is_stable(i_tmp
)) {
1327 svf_para
.runtest_run_state
= i_tmp
;
1329 /* When a run_state is specified, the new
1330 * run_state becomes the default end_state.
1332 svf_para
.runtest_end_state
= i_tmp
;
1333 LOG_DEBUG("\trun_state = %s", tap_state_name(i_tmp
));
1336 LOG_ERROR("%s: %s is not a stable state", argus
[0], tap_state_name(i_tmp
));
1341 /* run_count run_clk */
1342 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC")) {
1343 if (!strcmp(argus
[i
+ 1], "TCK")) {
1344 /* clock source is TCK */
1345 run_count
= atoi(argus
[i
]);
1346 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1348 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1354 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC")) {
1355 min_time
= atof(argus
[i
]);
1356 LOG_DEBUG("\tmin_time = %fs", min_time
);
1359 /* MAXIMUM max_time SEC */
1360 if (((i
+ 3) <= num_of_argu
) &&
1361 !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC")) {
1363 max_time
= atof(argus
[i
+ 1]);
1364 LOG_DEBUG("\tmax_time = %fs", max_time
);
1367 /* ENDSTATE end_state */
1368 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE")) {
1369 i_tmp
= tap_state_by_name(argus
[i
+ 1]);
1371 if (svf_tap_state_is_stable(i_tmp
)) {
1372 svf_para
.runtest_end_state
= i_tmp
;
1373 LOG_DEBUG("\tend_state = %s", tap_state_name(i_tmp
));
1375 LOG_ERROR("%s: %s is not a stable state", argus
[0], tap_state_name(i_tmp
));
1381 /* all parameter should be parsed */
1382 if (i
== num_of_argu
) {
1384 /* FIXME handle statemove failures */
1385 uint32_t min_usec
= 1000000 * min_time
;
1387 /* enter into run_state if necessary */
1388 if (cmd_queue_cur_state
!= svf_para
.runtest_run_state
)
1389 svf_add_statemove(svf_para
.runtest_run_state
);
1391 /* add clocks and/or min wait */
1392 if (run_count
> 0) {
1394 jtag_add_clocks(run_count
);
1399 jtag_add_sleep(min_usec
);
1402 /* move to end_state if necessary */
1403 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1404 svf_add_statemove(svf_para
.runtest_end_state
);
1407 if (svf_para
.runtest_run_state
!= TAP_IDLE
) {
1408 LOG_ERROR("cannot runtest in %s state",
1409 tap_state_name(svf_para
.runtest_run_state
));
1414 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1417 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed",
1424 /* STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state */
1425 if (num_of_argu
< 2) {
1426 LOG_ERROR("invalid parameter of %s", argus
[0]);
1429 if (num_of_argu
> 2) {
1430 /* STATE pathstate1 ... stable_state */
1431 path
= malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1433 LOG_ERROR("not enough memory");
1436 num_of_argu
--; /* num of path */
1437 i_tmp
= 1; /* path is from parameter 1 */
1438 for (i
= 0; i
< num_of_argu
; i
++, i_tmp
++) {
1439 path
[i
] = tap_state_by_name(argus
[i_tmp
]);
1440 if (path
[i
] == TAP_INVALID
) {
1441 LOG_ERROR("%s: %s is not a valid state", argus
[0], argus
[i_tmp
]);
1445 /* OpenOCD refuses paths containing TAP_RESET */
1446 if (TAP_RESET
== path
[i
]) {
1447 /* FIXME last state MUST be stable! */
1450 jtag_add_pathmove(i
, path
);
1454 num_of_argu
-= i
+ 1;
1458 if (num_of_argu
> 0) {
1459 /* execute last path if necessary */
1460 if (svf_tap_state_is_stable(path
[num_of_argu
- 1])) {
1461 /* last state MUST be stable state */
1463 jtag_add_pathmove(num_of_argu
, path
);
1464 LOG_DEBUG("\tmove to %s by path_move",
1465 tap_state_name(path
[num_of_argu
- 1]));
1467 LOG_ERROR("%s: %s is not a stable state",
1469 tap_state_name(path
[num_of_argu
- 1]));
1478 /* STATE stable_state */
1479 state
= tap_state_by_name(argus
[1]);
1480 if (svf_tap_state_is_stable(state
)) {
1481 LOG_DEBUG("\tmove to %s by svf_add_statemove",
1482 tap_state_name(state
));
1483 /* FIXME handle statemove failures */
1484 svf_add_statemove(state
);
1486 LOG_ERROR("%s: %s is not a stable state",
1487 argus
[0], tap_state_name(state
));
1493 /* TRST trst_mode */
1494 if (num_of_argu
!= 2) {
1495 LOG_ERROR("invalid parameter of %s", argus
[0]);
1498 if (svf_para
.trst_mode
!= TRST_ABSENT
) {
1499 if (ERROR_OK
!= svf_execute_tap())
1501 i_tmp
= svf_find_string_in_array(argus
[1],
1502 (char **)svf_trst_mode_name
,
1503 ARRAY_SIZE(svf_trst_mode_name
));
1507 jtag_add_reset(1, 0);
1512 jtag_add_reset(0, 0);
1517 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1520 svf_para
.trst_mode
= i_tmp
;
1521 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1523 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1528 LOG_ERROR("invalid svf command: %s", argus
[0]);
1534 if (padding_command_skipped
)
1535 LOG_USER("(Above Padding command skipped, as per -tap argument)");
1538 if (debug_level
>= LOG_LVL_DEBUG
) {
1539 /* for convenient debugging, execute tap if possible */
1540 if ((svf_buffer_index
> 0) && \
1541 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1542 ((command
== STATE
) && (num_of_argu
== 2)))) {
1543 if (ERROR_OK
!= svf_execute_tap())
1546 /* output debug info */
1547 if ((SIR
== command
) || (SDR
== command
)) {
1548 SVF_BUF_LOG(DEBUG
, svf_tdi_buffer
, svf_check_tdo_para
[0].bit_len
, "TDO read");
1552 /* for fast executing, execute tap if necessary */
1553 /* half of the buffer is for the next command */
1554 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) ||
1555 (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1556 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1557 ((command
== STATE
) && (num_of_argu
== 2))))
1558 return svf_execute_tap();
1564 static const struct command_registration svf_command_handlers
[] = {
1567 .handler
= handle_svf_command
,
1568 .mode
= COMMAND_EXEC
,
1569 .help
= "Runs a SVF file.",
1570 .usage
= "svf [-tap device.tap] <file> [quiet] [nil] [progress] [ignore_error]",
1572 COMMAND_REGISTRATION_DONE
1575 int svf_register_commands(struct command_context
*cmd_ctx
)
1577 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)