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
320 long long time_measure_ms
;
321 int time_measure_s
, time_measure_m
;
323 /* use NULL to indicate a "plain" svf file which accounts for
324 any additional devices in the scan chain, otherwise the device
325 that should be affected
327 struct jtag_tap
*tap
= NULL
;
329 if ((CMD_ARGC
< SVF_MIN_NUM_OF_OPTIONS
) || (CMD_ARGC
> SVF_MAX_NUM_OF_OPTIONS
))
331 return ERROR_COMMAND_SYNTAX_ERROR
;
334 // parse command line
336 for (unsigned int i
= 0; i
< CMD_ARGC
; i
++)
338 if (strcmp(CMD_ARGV
[i
], "-tap") == 0)
340 tap
= jtag_tap_by_string(CMD_ARGV
[i
+1]);
343 command_print(CMD_CTX
, "Tap: %s unknown", CMD_ARGV
[i
+1]);
348 else if ((strcmp(CMD_ARGV
[i
], "quiet") == 0) || (strcmp(CMD_ARGV
[i
], "-quiet") == 0))
352 else if ((strcmp(CMD_ARGV
[i
], "progress") == 0) || (strcmp(CMD_ARGV
[i
], "-progress") == 0))
354 svf_progress_enabled
= 1;
356 else if ((svf_fd
= fopen(CMD_ARGV
[i
], "r")) == NULL
)
359 command_print(CMD_CTX
, "open(\"%s\"): %s", CMD_ARGV
[i
], strerror(err
));
360 // no need to free anything now
361 return ERROR_COMMAND_SYNTAX_ERROR
;
365 LOG_USER("svf processing file: \"%s\"", CMD_ARGV
[i
]);
371 return ERROR_COMMAND_SYNTAX_ERROR
;
375 time_measure_ms
= timeval_ms();
379 svf_command_buffer_size
= 0;
381 svf_check_tdo_para_index
= 0;
382 svf_check_tdo_para
= malloc(sizeof(struct svf_check_tdo_para
) * SVF_CHECK_TDO_PARA_SIZE
);
383 if (NULL
== svf_check_tdo_para
)
385 LOG_ERROR("not enough memory");
390 svf_buffer_index
= 0;
391 // double the buffer size
392 // in case current command cannot be commited, and next command is a bit scan command
393 // here is 32K bits for this big scan command, it should be enough
394 // buffer will be reallocated if buffer size is not enough
395 svf_tdi_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
396 if (NULL
== svf_tdi_buffer
)
398 LOG_ERROR("not enough memory");
402 svf_tdo_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
403 if (NULL
== svf_tdo_buffer
)
405 LOG_ERROR("not enough memory");
409 svf_mask_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
410 if (NULL
== svf_mask_buffer
)
412 LOG_ERROR("not enough memory");
416 svf_buffer_size
= 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
;
418 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
425 /* Tap is specified, set header/trailer paddings */
426 int header_ir_len
= 0, header_dr_len
= 0, trailer_ir_len
= 0, trailer_dr_len
= 0;
427 struct jtag_tap
*check_tap
;
429 svf_tap_is_specified
= 1;
431 for (check_tap
= jtag_all_taps(); check_tap
; check_tap
= check_tap
->next_tap
) {
432 if (check_tap
->abs_chain_position
< tap
->abs_chain_position
)
435 header_ir_len
+= check_tap
->ir_length
;
438 else if (check_tap
->abs_chain_position
> tap
->abs_chain_position
)
441 trailer_ir_len
+= check_tap
->ir_length
;
447 if (ERROR_OK
!= svf_set_padding(&svf_para
.hdr_para
, header_dr_len
, 0))
449 LOG_ERROR("failed to set data header");
454 if (ERROR_OK
!= svf_set_padding(&svf_para
.hir_para
, header_ir_len
, 0xFF))
456 LOG_ERROR("failed to set instruction header");
461 if (ERROR_OK
!= svf_set_padding(&svf_para
.tdr_para
, trailer_dr_len
, 0))
463 LOG_ERROR("failed to set data trailer");
468 if (ERROR_OK
!= svf_set_padding(&svf_para
.tir_para
, trailer_ir_len
, 0xFF))
470 LOG_ERROR("failed to set instruction trailer");
476 if (svf_progress_enabled
)
478 // Count total lines in file.
479 while ( ! feof (svf_fd
) )
481 svf_getline (&svf_command_buffer
, &svf_command_buffer_size
, svf_fd
);
486 while (ERROR_OK
== svf_read_command_from_file(svf_fd
))
491 if (svf_progress_enabled
)
493 svf_percentage
= ((svf_line_number
* 20) / svf_total_lines
) * 5;
494 if (svf_last_printed_percentage
!= svf_percentage
)
496 LOG_USER_N("\r%d%% ", svf_percentage
);
497 svf_last_printed_percentage
= svf_percentage
;
503 if (svf_progress_enabled
)
505 svf_percentage
= ((svf_line_number
* 20) / svf_total_lines
) * 5;
506 LOG_USER_N("%3d%% %s", svf_percentage
, svf_read_line
);
510 LOG_USER_N("%s",svf_read_line
);
514 if (ERROR_OK
!= svf_run_command(CMD_CTX
, svf_command_buffer
))
516 LOG_ERROR("fail to run command at line %d", svf_line_number
);
522 if (ERROR_OK
!= jtag_execute_queue())
526 else if (ERROR_OK
!= svf_check_tdo())
532 time_measure_ms
= timeval_ms() - time_measure_ms
;
533 time_measure_s
= time_measure_ms
/ 1000;
534 time_measure_ms
%= 1000;
535 time_measure_m
= time_measure_s
/ 60;
536 time_measure_s
%= 60;
537 if (time_measure_ms
< 1000)
539 command_print(CMD_CTX
, "\r\nTime used: %dm%ds%lldms ", time_measure_m
, time_measure_s
, time_measure_ms
);
548 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
)
556 free(svf_check_tdo_para
);
557 svf_check_tdo_para
= NULL
;
558 svf_check_tdo_para_index
= 0;
562 free(svf_tdi_buffer
);
563 svf_tdi_buffer
= NULL
;
567 free(svf_tdo_buffer
);
568 svf_tdo_buffer
= NULL
;
572 free(svf_mask_buffer
);
573 svf_mask_buffer
= NULL
;
575 svf_buffer_index
= 0;
578 svf_free_xxd_para(&svf_para
.hdr_para
);
579 svf_free_xxd_para(&svf_para
.hir_para
);
580 svf_free_xxd_para(&svf_para
.tdr_para
);
581 svf_free_xxd_para(&svf_para
.tir_para
);
582 svf_free_xxd_para(&svf_para
.sdr_para
);
583 svf_free_xxd_para(&svf_para
.sir_para
);
587 command_print(CMD_CTX
, "svf file programmed successfully for %d commands", command_num
);
591 command_print(CMD_CTX
, "svf file programmed failed");
597 static int svf_getline (char **lineptr
, size_t *n
, FILE *stream
)
599 #define MIN_CHUNK 16 //Buffer is increased by this size each time as required
602 if (*lineptr
== NULL
)
605 *lineptr
= (char *)malloc (*n
);
612 (*lineptr
)[0] = fgetc(stream
);
613 while ((*lineptr
)[i
] != '\n')
615 (*lineptr
)[++i
] = fgetc(stream
);
624 *lineptr
= realloc(*lineptr
, *n
);
630 return sizeof(*lineptr
);
633 #define SVFP_CMD_INC_CNT 1024
634 static int svf_read_command_from_file(FILE * fd
)
639 int cmd_ok
= 0, slash
= 0, comment
= 0;
641 if (svf_getline (&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
646 ch
= svf_read_line
[0];
647 while (!cmd_ok
&& (ch
!= 0))
653 if (svf_getline (&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
664 if (svf_getline (&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
678 if (svf_getline (&svf_read_line
, &svf_read_line_size
, svf_fd
) <= 0)
686 /* Don't save '\r' and '\n' if no data is parsed */
690 /* The parsing code currently expects a space
691 * before parentheses -- "TDI (123)". Also a
692 * space afterwards -- "TDI (123) TDO(456)".
693 * But such spaces are optional... instead of
694 * parser updates, cope with that by adding the
697 * Ensure there are 3 bytes available, for:
698 * - current character
700 * - terminating NUL ('\0')
702 if ((cmd_pos
+ 2) >= svf_command_buffer_size
)
704 svf_command_buffer
= realloc(svf_command_buffer
, (cmd_pos
+ 2));
705 if (svf_command_buffer
== NULL
)
707 LOG_ERROR("not enough memory");
712 /* insert a space before '(' */
714 svf_command_buffer
[cmd_pos
++] = ' ';
716 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
718 /* insert a space after ')' */
720 svf_command_buffer
[cmd_pos
++] = ' ';
723 ch
= svf_read_line
[++i
];
728 svf_command_buffer
[cmd_pos
] = '\0';
737 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
739 int pos
= 0, num
= 0, space_found
= 1, in_bracket
= 0;
747 LOG_ERROR("fail to parse svf command");
757 if (!in_bracket
&& isspace((int) str
[pos
]))
762 else if (space_found
)
764 argus
[num
++] = &str
[pos
];
777 bool svf_tap_state_is_stable(tap_state_t state
)
779 return (TAP_RESET
== state
) || (TAP_IDLE
== state
)
780 || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
);
783 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
787 for (i
= 0; i
< num_of_element
; i
++)
789 if (!strcmp(str
, strs
[i
]))
797 static int svf_adjust_array_length(uint8_t **arr
, int orig_bit_len
, int new_bit_len
)
799 int new_byte_len
= (new_bit_len
+ 7) >> 3;
801 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3)))
808 *arr
= (uint8_t*)malloc(new_byte_len
);
811 LOG_ERROR("not enough memory");
814 memset(*arr
, 0, new_byte_len
);
819 static int svf_set_padding(struct svf_xxr_para
*para
, int len
, unsigned char tdi
)
821 int error
= ERROR_OK
;
822 error
|= svf_adjust_array_length(¶
->tdi
, para
->len
, len
);
823 memset(para
->tdi
, tdi
, (len
+ 7) >> 3);
824 error
|= svf_adjust_array_length(¶
->tdo
, para
->len
, len
);
825 error
|= svf_adjust_array_length(¶
->mask
, para
->len
, len
);
827 para
->data_mask
= XXR_TDI
;
832 static int svf_copy_hexstring_to_binary(char *str
, uint8_t **bin
, int orig_bit_len
, int bit_len
)
834 int i
, str_len
= strlen(str
), str_hbyte_len
= (bit_len
+ 3) >> 2;
837 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
))
839 LOG_ERROR("fail to adjust length of array");
843 /* fill from LSB (end of str) to MSB (beginning of str) */
844 for (i
= 0; i
< str_hbyte_len
; i
++)
851 /* Skip whitespace. The SVF specification (rev E) is
852 * deficient in terms of basic lexical issues like
853 * where whitespace is allowed. Long bitstrings may
854 * require line ends for correctness, since there is
855 * a hard limit on line length.
859 if ((ch
>= '0') && (ch
<= '9'))
864 else if ((ch
>= 'A') && (ch
<= 'F'))
871 LOG_ERROR("invalid hex string");
883 (*bin
)[i
/ 2] |= ch
<< 4;
893 /* consume optional leading '0' MSBs or whitespace */
894 while (str_len
> 0 && ((str
[str_len
- 1] == '0')
895 || isspace((int) str
[str_len
- 1])))
898 /* check validity: we must have consumed everything */
899 if (str_len
> 0 || (ch
& ~((2 << ((bit_len
- 1) % 4)) - 1)) != 0)
901 LOG_ERROR("value execeeds length");
908 static int svf_check_tdo(void)
910 int i
, len
, index_var
;
912 for (i
= 0; i
< svf_check_tdo_para_index
; i
++)
914 index_var
= svf_check_tdo_para
[i
].buffer_offset
;
915 len
= svf_check_tdo_para
[i
].bit_len
;
916 if ((svf_check_tdo_para
[i
].enabled
)
917 && buf_cmp_mask(&svf_tdi_buffer
[index_var
], &svf_tdo_buffer
[index_var
], &svf_mask_buffer
[index_var
], len
))
920 unsigned received
, expected
, tapmask
;
921 bitmask
= svf_get_mask_u32(svf_check_tdo_para
[i
].bit_len
);
923 memcpy(&received
, svf_tdi_buffer
+ index_var
, sizeof(unsigned));
924 memcpy(&expected
, svf_tdo_buffer
+ index_var
, sizeof(unsigned));
925 memcpy(&tapmask
, svf_mask_buffer
+ index_var
, sizeof(unsigned));
926 LOG_ERROR("tdo check error at line %d",
927 svf_check_tdo_para
[i
].line_num
);
928 LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
935 svf_check_tdo_para_index
= 0;
940 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
)
942 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
944 LOG_ERROR("toooooo many operation undone");
948 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
949 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
950 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
951 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
952 svf_check_tdo_para_index
++;
957 static int svf_execute_tap(void)
959 if (ERROR_OK
!= jtag_execute_queue())
963 else if (ERROR_OK
!= svf_check_tdo())
968 svf_buffer_index
= 0;
973 static int svf_run_command(struct command_context
*cmd_ctx
, char *cmd_str
)
975 char *argus
[256], command
;
976 int num_of_argu
= 0, i
;
983 float min_time
, max_time
;
985 struct svf_xxr_para
*xxr_para_tmp
;
986 uint8_t **pbuffer_tmp
;
987 struct scan_field field
;
989 tap_state_t
*path
= NULL
, state
;
990 // flag padding commands skipped due to -tap command
991 int padding_command_skipped
= 0;
993 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
998 /* NOTE: we're a bit loose here, because we ignore case in
999 * TAP state names (instead of insisting on uppercase).
1002 command
= svf_find_string_in_array(argus
[0],
1003 (char **)svf_command_name
, ARRAY_SIZE(svf_command_name
));
1008 if (num_of_argu
!= 2)
1010 LOG_ERROR("invalid parameter of %s", argus
[0]);
1014 i_tmp
= tap_state_by_name(argus
[1]);
1016 if (svf_tap_state_is_stable(i_tmp
))
1018 if (command
== ENDIR
)
1020 svf_para
.ir_end_state
= i_tmp
;
1021 LOG_DEBUG("\tIR end_state = %s",
1022 tap_state_name(i_tmp
));
1026 svf_para
.dr_end_state
= i_tmp
;
1027 LOG_DEBUG("\tDR end_state = %s",
1028 tap_state_name(i_tmp
));
1033 LOG_ERROR("%s: %s is not a stable state",
1034 argus
[0], argus
[1]);
1039 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
1041 LOG_ERROR("invalid parameter of %s", argus
[0]);
1044 if (1 == num_of_argu
)
1046 // TODO: set jtag speed to full speed
1047 svf_para
.frequency
= 0;
1051 if (strcmp(argus
[2], "HZ"))
1053 LOG_ERROR("HZ not found in FREQUENCY command");
1056 if (ERROR_OK
!= svf_execute_tap())
1060 svf_para
.frequency
= atof(argus
[1]);
1061 // TODO: set jtag speed to
1062 if (svf_para
.frequency
> 0)
1064 command_run_linef(cmd_ctx
, "adapter_khz %d", (int)svf_para
.frequency
/ 1000);
1065 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
1070 if (svf_tap_is_specified
)
1072 padding_command_skipped
= 1;
1075 xxr_para_tmp
= &svf_para
.hdr_para
;
1078 if (svf_tap_is_specified
)
1080 padding_command_skipped
= 1;
1083 xxr_para_tmp
= &svf_para
.hir_para
;
1086 if (svf_tap_is_specified
)
1088 padding_command_skipped
= 1;
1091 xxr_para_tmp
= &svf_para
.tdr_para
;
1094 if (svf_tap_is_specified
)
1096 padding_command_skipped
= 1;
1099 xxr_para_tmp
= &svf_para
.tir_para
;
1102 xxr_para_tmp
= &svf_para
.sdr_para
;
1105 xxr_para_tmp
= &svf_para
.sir_para
;
1108 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
1109 if ((num_of_argu
> 10) || (num_of_argu
% 2))
1111 LOG_ERROR("invalid parameter of %s", argus
[0]);
1114 i_tmp
= xxr_para_tmp
->len
;
1115 xxr_para_tmp
->len
= atoi(argus
[1]);
1116 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
1117 xxr_para_tmp
->data_mask
= 0;
1118 for (i
= 2; i
< num_of_argu
; i
+= 2)
1120 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
1122 LOG_ERROR("data section error");
1125 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
1126 // TDI, TDO, MASK, SMASK
1127 if (!strcmp(argus
[i
], "TDI"))
1130 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
1131 xxr_para_tmp
->data_mask
|= XXR_TDI
;
1133 else if (!strcmp(argus
[i
], "TDO"))
1136 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
1137 xxr_para_tmp
->data_mask
|= XXR_TDO
;
1139 else if (!strcmp(argus
[i
], "MASK"))
1142 pbuffer_tmp
= &xxr_para_tmp
->mask
;
1143 xxr_para_tmp
->data_mask
|= XXR_MASK
;
1145 else if (!strcmp(argus
[i
], "SMASK"))
1148 pbuffer_tmp
= &xxr_para_tmp
->smask
;
1149 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
1153 LOG_ERROR("unknow parameter: %s", argus
[i
]);
1156 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
1158 LOG_ERROR("fail to parse hex value");
1161 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & svf_get_mask_u32(xxr_para_tmp
->len
));
1163 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
1164 // the mask pattern used is all cares
1165 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
1167 // MASK not defined and length changed
1168 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
1170 LOG_ERROR("fail to adjust length of array");
1173 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
1175 // If TDO is absent, no comparison is needed, set the mask to 0
1176 if (!(xxr_para_tmp
->data_mask
& XXR_TDO
))
1178 if (NULL
== xxr_para_tmp
->tdo
)
1180 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->tdo
, i_tmp
, xxr_para_tmp
->len
))
1182 LOG_ERROR("fail to adjust length of array");
1186 if (NULL
== xxr_para_tmp
->mask
)
1188 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
1190 LOG_ERROR("fail to adjust length of array");
1194 memset(xxr_para_tmp
->mask
, 0, (xxr_para_tmp
->len
+ 7) >> 3);
1196 // do scan if necessary
1199 // check buffer size first, reallocate if necessary
1200 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
1201 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1204 // simply print error message
1205 LOG_ERROR("buffer is not enough, report to author");
1208 uint8_t *buffer_tmp
;
1210 // reallocate buffer
1211 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1212 if (NULL
== buffer_tmp
)
1214 LOG_ERROR("not enough memory");
1217 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1218 // svf_tdi_buffer isn't NULL here
1219 free(svf_tdi_buffer
);
1220 svf_tdi_buffer
= buffer_tmp
;
1222 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1223 if (NULL
== buffer_tmp
)
1225 LOG_ERROR("not enough memory");
1228 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1229 // svf_tdo_buffer isn't NULL here
1230 free(svf_tdo_buffer
);
1231 svf_tdo_buffer
= buffer_tmp
;
1233 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1234 if (NULL
== buffer_tmp
)
1236 LOG_ERROR("not enough memory");
1239 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1240 // svf_mask_buffer isn't NULL here
1241 free(svf_mask_buffer
);
1242 svf_mask_buffer
= buffer_tmp
;
1245 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1251 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1252 i
+= svf_para
.hdr_para
.len
;
1253 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1254 i
+= svf_para
.sdr_para
.len
;
1255 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1256 i
+= svf_para
.tdr_para
.len
;
1259 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
1261 // assemble dr mask data
1263 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1264 i
+= svf_para
.hdr_para
.len
;
1265 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1266 i
+= svf_para
.sdr_para
.len
;
1267 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1268 i
+= svf_para
.tdr_para
.len
;
1269 // assemble dr check data
1271 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1272 i
+= svf_para
.hdr_para
.len
;
1273 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1274 i
+= svf_para
.sdr_para
.len
;
1275 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1276 i
+= svf_para
.tdr_para
.len
;
1278 svf_add_check_para(1, svf_buffer_index
, i
);
1282 svf_add_check_para(0, svf_buffer_index
, i
);
1285 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1286 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1287 /* NOTE: doesn't use SVF-specified state paths */
1288 jtag_add_plain_dr_scan(field
.num_bits
, field
.out_value
, field
.in_value
, svf_para
.dr_end_state
);
1290 svf_buffer_index
+= (i
+ 7) >> 3;
1292 else if (SIR
== command
)
1294 // check buffer size first, reallocate if necessary
1295 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
1296 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1299 // simply print error message
1300 LOG_ERROR("buffer is not enough, report to author");
1303 uint8_t *buffer_tmp
;
1305 // reallocate buffer
1306 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1307 if (NULL
== buffer_tmp
)
1309 LOG_ERROR("not enough memory");
1312 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1313 // svf_tdi_buffer isn't NULL here
1314 free(svf_tdi_buffer
);
1315 svf_tdi_buffer
= buffer_tmp
;
1317 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1318 if (NULL
== buffer_tmp
)
1320 LOG_ERROR("not enough memory");
1323 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1324 // svf_tdo_buffer isn't NULL here
1325 free(svf_tdo_buffer
);
1326 svf_tdo_buffer
= buffer_tmp
;
1328 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1329 if (NULL
== buffer_tmp
)
1331 LOG_ERROR("not enough memory");
1334 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1335 // svf_mask_buffer isn't NULL here
1336 free(svf_mask_buffer
);
1337 svf_mask_buffer
= buffer_tmp
;
1340 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1346 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1347 i
+= svf_para
.hir_para
.len
;
1348 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1349 i
+= svf_para
.sir_para
.len
;
1350 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1351 i
+= svf_para
.tir_para
.len
;
1354 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1356 // assemble dr mask data
1358 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1359 i
+= svf_para
.hir_para
.len
;
1360 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1361 i
+= svf_para
.sir_para
.len
;
1362 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1363 i
+= svf_para
.tir_para
.len
;
1364 // assemble dr check data
1366 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1367 i
+= svf_para
.hir_para
.len
;
1368 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1369 i
+= svf_para
.sir_para
.len
;
1370 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1371 i
+= svf_para
.tir_para
.len
;
1373 svf_add_check_para(1, svf_buffer_index
, i
);
1377 svf_add_check_para(0, svf_buffer_index
, i
);
1380 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1381 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1382 /* NOTE: doesn't use SVF-specified state paths */
1383 jtag_add_plain_ir_scan(field
.num_bits
, field
.out_value
, field
.in_value
,
1384 svf_para
.ir_end_state
);
1386 svf_buffer_index
+= (i
+ 7) >> 3;
1391 LOG_ERROR("PIO and PIOMAP are not supported");
1395 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1396 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1397 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1399 LOG_ERROR("invalid parameter of %s", argus
[0]);
1409 i_tmp
= tap_state_by_name(argus
[i
]);
1410 if (i_tmp
!= TAP_INVALID
)
1412 if (svf_tap_state_is_stable(i_tmp
))
1414 svf_para
.runtest_run_state
= i_tmp
;
1416 /* When a run_state is specified, the new
1417 * run_state becomes the default end_state.
1419 svf_para
.runtest_end_state
= i_tmp
;
1420 LOG_DEBUG("\trun_state = %s",
1421 tap_state_name(i_tmp
));
1426 LOG_ERROR("%s: %s is not a stable state",
1427 argus
[0], tap_state_name(i_tmp
));
1432 // run_count run_clk
1433 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1435 if (!strcmp(argus
[i
+ 1], "TCK"))
1437 // clock source is TCK
1438 run_count
= atoi(argus
[i
]);
1439 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1443 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1449 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1451 min_time
= atof(argus
[i
]);
1452 LOG_DEBUG("\tmin_time = %fs", min_time
);
1455 // MAXIMUM max_time SEC
1456 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1458 max_time
= atof(argus
[i
+ 1]);
1459 LOG_DEBUG("\tmax_time = %fs", max_time
);
1462 // ENDSTATE end_state
1463 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1465 i_tmp
= tap_state_by_name(argus
[i
+ 1]);
1467 if (svf_tap_state_is_stable(i_tmp
))
1469 svf_para
.runtest_end_state
= i_tmp
;
1470 LOG_DEBUG("\tend_state = %s",
1471 tap_state_name(i_tmp
));
1475 LOG_ERROR("%s: %s is not a stable state",
1476 argus
[0], tap_state_name(i_tmp
));
1482 // all parameter should be parsed
1483 if (i
== num_of_argu
)
1486 /* FIXME handle statemove failures */
1488 uint32_t min_usec
= 1000000 * min_time
;
1490 // enter into run_state if necessary
1491 if (cmd_queue_cur_state
!= svf_para
.runtest_run_state
)
1493 retval
= svf_add_statemove(svf_para
.runtest_run_state
);
1496 // add clocks and/or min wait
1497 if (run_count
> 0) {
1498 jtag_add_clocks(run_count
);
1502 jtag_add_sleep(min_usec
);
1505 // move to end_state if necessary
1506 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1508 retval
= svf_add_statemove(svf_para
.runtest_end_state
);
1511 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1513 LOG_ERROR("cannot runtest in %s state",
1514 tap_state_name(svf_para
.runtest_run_state
));
1518 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1523 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1528 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1529 if (num_of_argu
< 2)
1531 LOG_ERROR("invalid parameter of %s", argus
[0]);
1534 if (num_of_argu
> 2)
1536 // STATE pathstate1 ... stable_state
1537 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1540 LOG_ERROR("not enough memory");
1543 num_of_argu
--; // num of path
1544 i_tmp
= 1; /* path is from parameter 1 */
1545 for (i
= 0; i
< num_of_argu
; i
++, i_tmp
++)
1547 path
[i
] = tap_state_by_name(argus
[i_tmp
]);
1548 if (path
[i
] == TAP_INVALID
)
1550 LOG_ERROR("%s: %s is not a valid state",
1551 argus
[0], argus
[i_tmp
]);
1555 /* OpenOCD refuses paths containing TAP_RESET */
1556 if (TAP_RESET
== path
[i
])
1558 /* FIXME last state MUST be stable! */
1561 jtag_add_pathmove(i
, path
);
1564 num_of_argu
-= i
+ 1;
1568 if (num_of_argu
> 0)
1570 // execute last path if necessary
1571 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1573 // last state MUST be stable state
1574 jtag_add_pathmove(num_of_argu
, path
);
1575 LOG_DEBUG("\tmove to %s by path_move",
1576 tap_state_name(path
[num_of_argu
- 1]));
1580 LOG_ERROR("%s: %s is not a stable state",
1582 tap_state_name(path
[num_of_argu
- 1]));
1593 // STATE stable_state
1594 state
= tap_state_by_name(argus
[1]);
1595 if (svf_tap_state_is_stable(state
))
1597 LOG_DEBUG("\tmove to %s by svf_add_statemove",
1598 tap_state_name(state
));
1599 /* FIXME handle statemove failures */
1600 svf_add_statemove(state
);
1604 LOG_ERROR("%s: %s is not a stable state",
1605 argus
[0], tap_state_name(state
));
1612 if (num_of_argu
!= 2)
1614 LOG_ERROR("invalid parameter of %s", argus
[0]);
1617 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1619 if (ERROR_OK
!= svf_execute_tap())
1623 i_tmp
= svf_find_string_in_array(argus
[1],
1624 (char **)svf_trst_mode_name
,
1625 ARRAY_SIZE(svf_trst_mode_name
));
1629 jtag_add_reset(1, 0);
1633 jtag_add_reset(0, 0);
1638 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1641 svf_para
.trst_mode
= i_tmp
;
1642 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1646 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1651 LOG_ERROR("invalid svf command: %s", argus
[0]);
1658 if (padding_command_skipped
)
1660 LOG_USER("(Above Padding command skipped, as per -tap argument)");
1664 if (debug_level
>= LOG_LVL_DEBUG
)
1666 // for convenient debugging, execute tap if possible
1667 if ((svf_buffer_index
> 0) && \
1668 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1669 ((command
== STATE
) && (num_of_argu
== 2))))
1671 if (ERROR_OK
!= svf_execute_tap())
1676 // output debug info
1677 if ((SIR
== command
) || (SDR
== command
))
1680 memcpy(&read_value
, svf_tdi_buffer
, sizeof(int));
1681 // in debug mode, data is from index 0
1682 int read_mask
= svf_get_mask_u32(svf_check_tdo_para
[0].bit_len
);
1683 LOG_DEBUG("\tTDO read = 0x%X", read_value
& read_mask
);
1689 // for fast executing, execute tap if necessary
1690 // half of the buffer is for the next command
1691 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1692 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1693 ((command
== STATE
) && (num_of_argu
== 2))))
1695 return svf_execute_tap();
1702 static const struct command_registration svf_command_handlers
[] = {
1705 .handler
= handle_svf_command
,
1706 .mode
= COMMAND_EXEC
,
1707 .help
= "Runs a SVF file.",
1708 .usage
= "svf [-tap device.tap] <file> [quiet] [progress]",
1710 COMMAND_REGISTRATION_DONE
1713 int svf_register_commands(struct command_context
*cmd_ctx
)
1715 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)