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(int 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 int svf_fd
= 0;
215 static char *svf_command_buffer
= NULL
;
216 static int svf_command_buffer_size
= 0;
217 static int svf_line_number
= 1;
219 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (4 * 1024)
220 static uint8_t *svf_tdi_buffer
= NULL
, *svf_tdo_buffer
= NULL
, *svf_mask_buffer
= NULL
;
221 static int svf_buffer_index
= 0, svf_buffer_size
= 0;
222 static int svf_quiet
= 0;
225 static void svf_free_xxd_para(struct svf_xxr_para
*para
)
229 if (para
->tdi
!= NULL
)
234 if (para
->tdo
!= NULL
)
239 if (para
->mask
!= NULL
)
244 if (para
->smask
!= NULL
)
252 static unsigned svf_get_mask_u32(int bitlen
)
260 else if (bitlen
>= 32)
262 bitmask
= 0xFFFFFFFF;
266 bitmask
= (1 << bitlen
) - 1;
272 int svf_add_statemove(tap_state_t state_to
)
274 tap_state_t state_from
= cmd_queue_cur_state
;
277 /* when resetting, be paranoid and ignore current state */
278 if (state_to
== TAP_RESET
) {
283 for (index
= 0; index
< ARRAY_SIZE(svf_statemoves
); index
++)
285 if ((svf_statemoves
[index
].from
== state_from
)
286 && (svf_statemoves
[index
].to
== state_to
))
288 /* recorded path includes current state ... avoid extra TCKs! */
289 if (svf_statemoves
[index
].num_of_moves
> 1)
290 jtag_add_pathmove(svf_statemoves
[index
].num_of_moves
- 1,
291 svf_statemoves
[index
].paths
+ 1);
293 jtag_add_pathmove(svf_statemoves
[index
].num_of_moves
,
294 svf_statemoves
[index
].paths
);
298 LOG_ERROR("SVF: can not move to %s", tap_state_name(state_to
));
302 COMMAND_HANDLER(handle_svf_command
)
304 #define SVF_NUM_OF_OPTIONS 1
309 if ((CMD_ARGC
< 1) || (CMD_ARGC
> (1 + SVF_NUM_OF_OPTIONS
)))
311 command_print(CMD_CTX
, "usage: svf <file> [quiet]");
317 for (unsigned i
= 1; i
< CMD_ARGC
; i
++)
319 if (!strcmp(CMD_ARGV
[i
], "quiet"))
325 LOG_ERROR("unknown variant for svf: %s", CMD_ARGV
[i
]);
327 // no need to free anything now
332 if ((svf_fd
= open(CMD_ARGV
[0], O_RDONLY
)) < 0)
334 command_print(CMD_CTX
, "file \"%s\" not found", CMD_ARGV
[0]);
336 // no need to free anything now
340 LOG_USER("svf processing file: \"%s\"", CMD_ARGV
[0]);
343 time_ago
= timeval_ms();
347 svf_command_buffer_size
= 0;
349 svf_check_tdo_para_index
= 0;
350 svf_check_tdo_para
= malloc(sizeof(struct svf_check_tdo_para
) * SVF_CHECK_TDO_PARA_SIZE
);
351 if (NULL
== svf_check_tdo_para
)
353 LOG_ERROR("not enough memory");
358 svf_buffer_index
= 0;
359 // double the buffer size
360 // in case current command cannot be commited, and next command is a bit scan command
361 // here is 32K bits for this big scan command, it should be enough
362 // buffer will be reallocated if buffer size is not enough
363 svf_tdi_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
364 if (NULL
== svf_tdi_buffer
)
366 LOG_ERROR("not enough memory");
370 svf_tdo_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
371 if (NULL
== svf_tdo_buffer
)
373 LOG_ERROR("not enough memory");
377 svf_mask_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
378 if (NULL
== svf_mask_buffer
)
380 LOG_ERROR("not enough memory");
384 svf_buffer_size
= 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
;
386 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
391 while (ERROR_OK
== svf_read_command_from_file(svf_fd
))
393 if (ERROR_OK
!= svf_run_command(CMD_CTX
, svf_command_buffer
))
395 LOG_ERROR("fail to run command at line %d", svf_line_number
);
401 if (ERROR_OK
!= jtag_execute_queue())
405 else if (ERROR_OK
!= svf_check_tdo())
411 command_print(CMD_CTX
, "%lld ms used", timeval_ms() - time_ago
);
419 if (svf_command_buffer
)
421 free(svf_command_buffer
);
422 svf_command_buffer
= NULL
;
423 svf_command_buffer_size
= 0;
425 if (svf_check_tdo_para
)
427 free(svf_check_tdo_para
);
428 svf_check_tdo_para
= NULL
;
429 svf_check_tdo_para_index
= 0;
433 free(svf_tdi_buffer
);
434 svf_tdi_buffer
= NULL
;
438 free(svf_tdo_buffer
);
439 svf_tdo_buffer
= NULL
;
443 free(svf_mask_buffer
);
444 svf_mask_buffer
= NULL
;
446 svf_buffer_index
= 0;
449 svf_free_xxd_para(&svf_para
.hdr_para
);
450 svf_free_xxd_para(&svf_para
.hir_para
);
451 svf_free_xxd_para(&svf_para
.tdr_para
);
452 svf_free_xxd_para(&svf_para
.tir_para
);
453 svf_free_xxd_para(&svf_para
.sdr_para
);
454 svf_free_xxd_para(&svf_para
.sir_para
);
458 command_print(CMD_CTX
, "svf file programmed successfully for %d commands", command_num
);
462 command_print(CMD_CTX
, "svf file programmed failed");
468 #define SVFP_CMD_INC_CNT 1024
469 static int svf_read_command_from_file(int fd
)
472 char *tmp_buffer
= NULL
;
473 int cmd_pos
= 0, cmd_ok
= 0, slash
= 0, comment
= 0;
475 while (!cmd_ok
&& (read(fd
, &ch
, 1) > 0))
501 /* Don't save '\r' and '\n' if no data is parsed */
507 /* The parsing code currently expects a space
508 * before parentheses -- "TDI (123)". Also a
509 * space afterwards -- "TDI (123) TDO(456)".
510 * But such spaces are optional... instead of
511 * parser updates, cope with that by adding the
514 * Ensure there are 3 bytes available, for:
515 * - current character
517 * - terminating NUL ('\0')
519 if ((cmd_pos
+ 2) >= svf_command_buffer_size
)
521 /* REVISIT use realloc(); simpler */
523 svf_command_buffer_size
525 if (NULL
== tmp_buffer
)
527 LOG_ERROR("not enough memory");
530 if (svf_command_buffer_size
> 0)
533 svf_command_buffer_size
);
534 if (svf_command_buffer
!= NULL
)
535 free(svf_command_buffer
);
536 svf_command_buffer
= tmp_buffer
;
537 svf_command_buffer_size
+= SVFP_CMD_INC_CNT
;
541 /* insert a space before '(' */
543 svf_command_buffer
[cmd_pos
++] = ' ';
545 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
547 /* insert a space after ')' */
549 svf_command_buffer
[cmd_pos
++] = ' ';
557 svf_command_buffer
[cmd_pos
] = '\0';
566 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
568 int pos
= 0, num
= 0, space_found
= 1, in_bracket
= 0;
576 LOG_ERROR("fail to parse svf command");
586 if (!in_bracket
&& isspace((int) str
[pos
]))
591 else if (space_found
)
593 argus
[num
++] = &str
[pos
];
606 bool svf_tap_state_is_stable(tap_state_t state
)
608 return (TAP_RESET
== state
) || (TAP_IDLE
== state
)
609 || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
);
612 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
616 for (i
= 0; i
< num_of_element
; i
++)
618 if (!strcmp(str
, strs
[i
]))
626 static int svf_adjust_array_length(uint8_t **arr
, int orig_bit_len
, int new_bit_len
)
628 int new_byte_len
= (new_bit_len
+ 7) >> 3;
630 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3)))
637 *arr
= (uint8_t*)malloc(new_byte_len
);
640 LOG_ERROR("not enough memory");
643 memset(*arr
, 0, new_byte_len
);
648 static int svf_copy_hexstring_to_binary(char *str
, uint8_t **bin
, int orig_bit_len
, int bit_len
)
650 int i
, str_len
= strlen(str
), str_hbyte_len
= (bit_len
+ 3) >> 2;
653 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
))
655 LOG_ERROR("fail to adjust length of array");
659 /* fill from LSB (end of str) to MSB (beginning of str) */
660 for (i
= 0; i
< str_hbyte_len
; i
++)
667 /* Skip whitespace. The SVF specification (rev E) is
668 * deficient in terms of basic lexical issues like
669 * where whitespace is allowed. Long bitstrings may
670 * require line ends for correctness, since there is
671 * a hard limit on line length.
675 if ((ch
>= '0') && (ch
<= '9'))
680 else if ((ch
>= 'A') && (ch
<= 'F'))
687 LOG_ERROR("invalid hex string");
699 (*bin
)[i
/ 2] |= ch
<< 4;
709 /* consume optional leading '0' MSBs or whitespace */
710 while (str_len
> 0 && ((str
[str_len
- 1] == '0')
711 || isspace((int) str
[str_len
- 1])))
714 /* check validity: we must have consumed everything */
715 if (str_len
> 0 || (ch
& ~((2 << ((bit_len
- 1) % 4)) - 1)) != 0)
717 LOG_ERROR("value execeeds length");
724 static int svf_check_tdo(void)
728 for (i
= 0; i
< svf_check_tdo_para_index
; i
++)
730 index
= svf_check_tdo_para
[i
].buffer_offset
;
731 len
= svf_check_tdo_para
[i
].bit_len
;
732 if ((svf_check_tdo_para
[i
].enabled
)
733 && buf_cmp_mask(&svf_tdi_buffer
[index
], &svf_tdo_buffer
[index
], &svf_mask_buffer
[index
], len
))
736 unsigned received
, expected
, tapmask
;
737 bitmask
= svf_get_mask_u32(svf_check_tdo_para
[i
].bit_len
);
739 memcpy(&received
, svf_tdi_buffer
+ index
, sizeof(unsigned));
740 memcpy(&expected
, svf_tdo_buffer
+ index
, sizeof(unsigned));
741 memcpy(&tapmask
, svf_mask_buffer
+ index
, sizeof(unsigned));
742 LOG_ERROR("tdo check error at line %d",
743 svf_check_tdo_para
[i
].line_num
);
744 LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
751 svf_check_tdo_para_index
= 0;
756 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
)
758 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
760 LOG_ERROR("toooooo many operation undone");
764 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
765 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
766 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
767 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
768 svf_check_tdo_para_index
++;
773 static int svf_execute_tap(void)
775 if (ERROR_OK
!= jtag_execute_queue())
779 else if (ERROR_OK
!= svf_check_tdo())
784 svf_buffer_index
= 0;
789 static int svf_run_command(struct command_context
*cmd_ctx
, char *cmd_str
)
791 char *argus
[256], command
;
792 int num_of_argu
= 0, i
;
799 float min_time
, max_time
;
801 struct svf_xxr_para
*xxr_para_tmp
;
802 uint8_t **pbuffer_tmp
;
803 struct scan_field field
;
805 tap_state_t
*path
= NULL
, state
;
809 LOG_USER("%s", svf_command_buffer
);
812 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
817 /* NOTE: we're a bit loose here, because we ignore case in
818 * TAP state names (instead of insisting on uppercase).
821 command
= svf_find_string_in_array(argus
[0],
822 (char **)svf_command_name
, ARRAY_SIZE(svf_command_name
));
827 if (num_of_argu
!= 2)
829 LOG_ERROR("invalid parameter of %s", argus
[0]);
833 i_tmp
= tap_state_by_name(argus
[1]);
835 if (svf_tap_state_is_stable(i_tmp
))
837 if (command
== ENDIR
)
839 svf_para
.ir_end_state
= i_tmp
;
840 LOG_DEBUG("\tIR end_state = %s",
841 tap_state_name(i_tmp
));
845 svf_para
.dr_end_state
= i_tmp
;
846 LOG_DEBUG("\tDR end_state = %s",
847 tap_state_name(i_tmp
));
852 LOG_ERROR("%s: %s is not a stable state",
858 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
860 LOG_ERROR("invalid parameter of %s", argus
[0]);
863 if (1 == num_of_argu
)
865 // TODO: set jtag speed to full speed
866 svf_para
.frequency
= 0;
870 if (strcmp(argus
[2], "HZ"))
872 LOG_ERROR("HZ not found in FREQUENCY command");
875 if (ERROR_OK
!= svf_execute_tap())
879 svf_para
.frequency
= atof(argus
[1]);
880 // TODO: set jtag speed to
881 if (svf_para
.frequency
> 0)
883 command_run_linef(cmd_ctx
, "adapter_khz %d", (int)svf_para
.frequency
/ 1000);
884 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
889 xxr_para_tmp
= &svf_para
.hdr_para
;
892 xxr_para_tmp
= &svf_para
.hir_para
;
895 xxr_para_tmp
= &svf_para
.tdr_para
;
898 xxr_para_tmp
= &svf_para
.tir_para
;
901 xxr_para_tmp
= &svf_para
.sdr_para
;
904 xxr_para_tmp
= &svf_para
.sir_para
;
907 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
908 if ((num_of_argu
> 10) || (num_of_argu
% 2))
910 LOG_ERROR("invalid parameter of %s", argus
[0]);
913 i_tmp
= xxr_para_tmp
->len
;
914 xxr_para_tmp
->len
= atoi(argus
[1]);
915 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
916 xxr_para_tmp
->data_mask
= 0;
917 for (i
= 2; i
< num_of_argu
; i
+= 2)
919 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
921 LOG_ERROR("data section error");
924 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
925 // TDI, TDO, MASK, SMASK
926 if (!strcmp(argus
[i
], "TDI"))
929 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
930 xxr_para_tmp
->data_mask
|= XXR_TDI
;
932 else if (!strcmp(argus
[i
], "TDO"))
935 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
936 xxr_para_tmp
->data_mask
|= XXR_TDO
;
938 else if (!strcmp(argus
[i
], "MASK"))
941 pbuffer_tmp
= &xxr_para_tmp
->mask
;
942 xxr_para_tmp
->data_mask
|= XXR_MASK
;
944 else if (!strcmp(argus
[i
], "SMASK"))
947 pbuffer_tmp
= &xxr_para_tmp
->smask
;
948 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
952 LOG_ERROR("unknow parameter: %s", argus
[i
]);
955 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
957 LOG_ERROR("fail to parse hex value");
960 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & svf_get_mask_u32(xxr_para_tmp
->len
));
962 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
963 // the mask pattern used is all cares
964 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
966 // MASK not defined and length changed
967 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
969 LOG_ERROR("fail to adjust length of array");
972 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
974 // If TDO is absent, no comparison is needed, set the mask to 0
975 if (!(xxr_para_tmp
->data_mask
& XXR_TDO
))
977 if (NULL
== xxr_para_tmp
->tdo
)
979 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->tdo
, i_tmp
, xxr_para_tmp
->len
))
981 LOG_ERROR("fail to adjust length of array");
985 if (NULL
== xxr_para_tmp
->mask
)
987 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
989 LOG_ERROR("fail to adjust length of array");
993 memset(xxr_para_tmp
->mask
, 0, (xxr_para_tmp
->len
+ 7) >> 3);
995 // do scan if necessary
998 // check buffer size first, reallocate if necessary
999 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
1000 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1003 // simply print error message
1004 LOG_ERROR("buffer is not enough, report to author");
1007 uint8_t *buffer_tmp
;
1009 // reallocate buffer
1010 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1011 if (NULL
== buffer_tmp
)
1013 LOG_ERROR("not enough memory");
1016 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1017 // svf_tdi_buffer isn't NULL here
1018 free(svf_tdi_buffer
);
1019 svf_tdi_buffer
= buffer_tmp
;
1021 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1022 if (NULL
== buffer_tmp
)
1024 LOG_ERROR("not enough memory");
1027 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1028 // svf_tdo_buffer isn't NULL here
1029 free(svf_tdo_buffer
);
1030 svf_tdo_buffer
= buffer_tmp
;
1032 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1033 if (NULL
== buffer_tmp
)
1035 LOG_ERROR("not enough memory");
1038 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1039 // svf_mask_buffer isn't NULL here
1040 free(svf_mask_buffer
);
1041 svf_mask_buffer
= buffer_tmp
;
1044 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1050 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1051 i
+= svf_para
.hdr_para
.len
;
1052 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1053 i
+= svf_para
.sdr_para
.len
;
1054 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1055 i
+= svf_para
.tdr_para
.len
;
1058 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
1060 // assemble dr mask data
1062 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1063 i
+= svf_para
.hdr_para
.len
;
1064 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1065 i
+= svf_para
.sdr_para
.len
;
1066 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1067 i
+= svf_para
.tdr_para
.len
;
1068 // assemble dr check data
1070 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1071 i
+= svf_para
.hdr_para
.len
;
1072 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1073 i
+= svf_para
.sdr_para
.len
;
1074 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1075 i
+= svf_para
.tdr_para
.len
;
1077 svf_add_check_para(1, svf_buffer_index
, i
);
1081 svf_add_check_para(0, svf_buffer_index
, i
);
1084 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1085 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1086 /* NOTE: doesn't use SVF-specified state paths */
1087 jtag_add_plain_dr_scan(field
.num_bits
, field
.out_value
, field
.in_value
, svf_para
.dr_end_state
);
1089 svf_buffer_index
+= (i
+ 7) >> 3;
1091 else if (SIR
== command
)
1093 // check buffer size first, reallocate if necessary
1094 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
1095 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1098 // simply print error message
1099 LOG_ERROR("buffer is not enough, report to author");
1102 uint8_t *buffer_tmp
;
1104 // reallocate buffer
1105 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1106 if (NULL
== buffer_tmp
)
1108 LOG_ERROR("not enough memory");
1111 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1112 // svf_tdi_buffer isn't NULL here
1113 free(svf_tdi_buffer
);
1114 svf_tdi_buffer
= buffer_tmp
;
1116 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1117 if (NULL
== buffer_tmp
)
1119 LOG_ERROR("not enough memory");
1122 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1123 // svf_tdo_buffer isn't NULL here
1124 free(svf_tdo_buffer
);
1125 svf_tdo_buffer
= buffer_tmp
;
1127 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1128 if (NULL
== buffer_tmp
)
1130 LOG_ERROR("not enough memory");
1133 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1134 // svf_mask_buffer isn't NULL here
1135 free(svf_mask_buffer
);
1136 svf_mask_buffer
= buffer_tmp
;
1139 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1145 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1146 i
+= svf_para
.hir_para
.len
;
1147 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1148 i
+= svf_para
.sir_para
.len
;
1149 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1150 i
+= svf_para
.tir_para
.len
;
1153 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1155 // assemble dr mask data
1157 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1158 i
+= svf_para
.hir_para
.len
;
1159 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1160 i
+= svf_para
.sir_para
.len
;
1161 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1162 i
+= svf_para
.tir_para
.len
;
1163 // assemble dr check data
1165 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1166 i
+= svf_para
.hir_para
.len
;
1167 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1168 i
+= svf_para
.sir_para
.len
;
1169 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1170 i
+= svf_para
.tir_para
.len
;
1172 svf_add_check_para(1, svf_buffer_index
, i
);
1176 svf_add_check_para(0, svf_buffer_index
, i
);
1179 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1180 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1181 /* NOTE: doesn't use SVF-specified state paths */
1182 jtag_add_plain_ir_scan(field
.num_bits
, field
.out_value
, field
.in_value
,
1183 svf_para
.ir_end_state
);
1185 svf_buffer_index
+= (i
+ 7) >> 3;
1190 LOG_ERROR("PIO and PIOMAP are not supported");
1194 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1195 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1196 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1198 LOG_ERROR("invalid parameter of %s", argus
[0]);
1208 i_tmp
= tap_state_by_name(argus
[i
]);
1209 if (i_tmp
!= TAP_INVALID
)
1211 if (svf_tap_state_is_stable(i_tmp
))
1213 svf_para
.runtest_run_state
= i_tmp
;
1215 /* When a run_state is specified, the new
1216 * run_state becomes the default end_state.
1218 svf_para
.runtest_end_state
= i_tmp
;
1219 LOG_DEBUG("\trun_state = %s",
1220 tap_state_name(i_tmp
));
1225 LOG_ERROR("%s: %s is not a stable state",
1226 argus
[0], tap_state_name(i_tmp
));
1231 // run_count run_clk
1232 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1234 if (!strcmp(argus
[i
+ 1], "TCK"))
1236 // clock source is TCK
1237 run_count
= atoi(argus
[i
]);
1238 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1242 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1248 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1250 min_time
= atof(argus
[i
]);
1251 LOG_DEBUG("\tmin_time = %fs", min_time
);
1254 // MAXIMUM max_time SEC
1255 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1257 max_time
= atof(argus
[i
+ 1]);
1258 LOG_DEBUG("\tmax_time = %fs", max_time
);
1261 // ENDSTATE end_state
1262 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1264 i_tmp
= tap_state_by_name(argus
[i
+ 1]);
1266 if (svf_tap_state_is_stable(i_tmp
))
1268 svf_para
.runtest_end_state
= i_tmp
;
1269 LOG_DEBUG("\tend_state = %s",
1270 tap_state_name(i_tmp
));
1274 LOG_ERROR("%s: %s is not a stable state",
1275 argus
[0], tap_state_name(i_tmp
));
1280 // calculate run_count
1281 if ((0 == run_count
) && (min_time
> 0))
1283 run_count
= min_time
* svf_para
.frequency
;
1285 // all parameter should be parsed
1286 if (i
== num_of_argu
)
1290 // run_state and end_state is checked to be stable state
1293 /* FIXME handle statemove failures */
1296 // enter into run_state if necessary
1297 if (cmd_queue_cur_state
!= svf_para
.runtest_run_state
)
1299 retval
= svf_add_statemove(svf_para
.runtest_run_state
);
1302 // call jtag_add_clocks
1303 jtag_add_clocks(run_count
);
1305 // move to end_state if necessary
1306 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1308 retval
= svf_add_statemove(svf_para
.runtest_end_state
);
1311 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1313 LOG_ERROR("cannot runtest in %s state",
1314 tap_state_name(svf_para
.runtest_run_state
));
1318 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1324 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1329 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1330 if (num_of_argu
< 2)
1332 LOG_ERROR("invalid parameter of %s", argus
[0]);
1335 if (num_of_argu
> 2)
1337 // STATE pathstate1 ... stable_state
1338 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1341 LOG_ERROR("not enough memory");
1344 num_of_argu
--; // num of path
1345 i_tmp
= 1; /* path is from parameter 1 */
1346 for (i
= 0; i
< num_of_argu
; i
++, i_tmp
++)
1348 path
[i
] = tap_state_by_name(argus
[i_tmp
]);
1349 if (path
[i
] == TAP_INVALID
)
1351 LOG_ERROR("%s: %s is not a valid state",
1352 argus
[0], argus
[i_tmp
]);
1356 /* OpenOCD refuses paths containing TAP_RESET */
1357 if (TAP_RESET
== path
[i
])
1359 /* FIXME last state MUST be stable! */
1362 jtag_add_pathmove(i
, path
);
1365 num_of_argu
-= i
+ 1;
1369 if (num_of_argu
> 0)
1371 // execute last path if necessary
1372 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1374 // last state MUST be stable state
1375 jtag_add_pathmove(num_of_argu
, path
);
1376 LOG_DEBUG("\tmove to %s by path_move",
1377 tap_state_name(path
[num_of_argu
- 1]));
1381 LOG_ERROR("%s: %s is not a stable state",
1383 tap_state_name(path
[num_of_argu
- 1]));
1394 // STATE stable_state
1395 state
= tap_state_by_name(argus
[1]);
1396 if (svf_tap_state_is_stable(state
))
1398 LOG_DEBUG("\tmove to %s by svf_add_statemove",
1399 tap_state_name(state
));
1400 /* FIXME handle statemove failures */
1401 svf_add_statemove(state
);
1405 LOG_ERROR("%s: %s is not a stable state",
1406 argus
[0], tap_state_name(state
));
1413 if (num_of_argu
!= 2)
1415 LOG_ERROR("invalid parameter of %s", argus
[0]);
1418 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1420 if (ERROR_OK
!= svf_execute_tap())
1424 i_tmp
= svf_find_string_in_array(argus
[1],
1425 (char **)svf_trst_mode_name
,
1426 ARRAY_SIZE(svf_trst_mode_name
));
1430 jtag_add_reset(1, 0);
1434 jtag_add_reset(0, 0);
1439 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1442 svf_para
.trst_mode
= i_tmp
;
1443 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1447 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1452 LOG_ERROR("invalid svf command: %s", argus
[0]);
1457 if (debug_level
>= LOG_LVL_DEBUG
)
1459 // for convenient debugging, execute tap if possible
1460 if ((svf_buffer_index
> 0) && \
1461 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1462 ((command
== STATE
) && (num_of_argu
== 2))))
1464 if (ERROR_OK
!= svf_execute_tap())
1469 // output debug info
1470 if ((SIR
== command
) || (SDR
== command
))
1473 memcpy(&read_value
, svf_tdi_buffer
, sizeof(int));
1474 // in debug mode, data is from index 0
1475 int read_mask
= svf_get_mask_u32(svf_check_tdo_para
[0].bit_len
);
1476 LOG_DEBUG("\tTDO read = 0x%X", read_value
& read_mask
);
1482 // for fast executing, execute tap if necessary
1483 // half of the buffer is for the next command
1484 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1485 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1486 ((command
== STATE
) && (num_of_argu
== 2))))
1488 return svf_execute_tap();
1495 static const struct command_registration svf_command_handlers
[] = {
1498 .handler
= handle_svf_command
,
1499 .mode
= COMMAND_EXEC
,
1500 .help
= "Runs a SVF file.",
1501 .usage
= "filename ['quiet']",
1503 COMMAND_REGISTRATION_DONE
1506 int svf_register_commands(struct command_context
*cmd_ctx
)
1508 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)