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".
36 #include "time_support.h"
58 const char *svf_command_name
[14] =
84 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 svf_statemove_t 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
}}
139 char *svf_tap_state_name
[TAP_NUM_STATES
];
141 #define XXR_TDI (1 << 0)
142 #define XXR_TDO (1 << 1)
143 #define XXR_MASK (1 << 2)
144 #define XXR_SMASK (1 << 3)
158 tap_state_t ir_end_state
;
159 tap_state_t dr_end_state
;
160 tap_state_t runtest_run_state
;
161 tap_state_t runtest_end_state
;
162 trst_mode_t trst_mode
;
164 svf_xxr_para_t hir_para
;
165 svf_xxr_para_t hdr_para
;
166 svf_xxr_para_t tir_para
;
167 svf_xxr_para_t tdr_para
;
168 svf_xxr_para_t sir_para
;
169 svf_xxr_para_t sdr_para
;
173 const svf_para_t svf_para_init
=
175 // frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode
176 0, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TRST_Z
,
178 // {len, data_mask, tdi, tdo, mask, smask},
179 {0, 0, NULL
, NULL
, NULL
, NULL
},
181 // {len, data_mask, tdi, tdo, mask, smask},
182 {0, 0, NULL
, NULL
, NULL
, NULL
},
184 // {len, data_mask, tdi, tdo, mask, smask},
185 {0, 0, NULL
, NULL
, NULL
, NULL
},
187 // {len, data_mask, tdi, tdo, mask, smask},
188 {0, 0, NULL
, NULL
, NULL
, NULL
},
190 // {len, data_mask, tdi, tdo, mask, smask},
191 {0, 0, NULL
, NULL
, NULL
, NULL
},
193 // {len, data_mask, tdi, tdo, mask, smask},
194 {0, 0, NULL
, NULL
, NULL
, NULL
},
199 int line_num
; // used to record line number of the check operation
200 // so more information could be printed
201 int enabled
; // check is enabled or not
202 int buffer_offset
; // buffer_offset to buffers
203 int bit_len
; // bit length to check
204 }svf_check_tdo_para_t
;
206 #define SVF_CHECK_TDO_PARA_SIZE 1024
207 static svf_check_tdo_para_t
*svf_check_tdo_para
= NULL
;
208 static int svf_check_tdo_para_index
= 0;
210 #define dimof(a) (sizeof(a) / sizeof((a)[0]))
212 static int svf_read_command_from_file(int fd
);
213 static int svf_check_tdo(void);
214 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
);
215 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
);
216 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
218 static int svf_fd
= 0;
219 static char *svf_command_buffer
= NULL
;
220 static int svf_command_buffer_size
= 0;
221 static int svf_line_number
= 1;
223 static jtag_tap_t
*tap
= NULL
;
225 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (4 * 1024)
226 static uint8_t *svf_tdi_buffer
= NULL
, *svf_tdo_buffer
= NULL
, *svf_mask_buffer
= NULL
;
227 static int svf_buffer_index
= 0, svf_buffer_size
= 0;
228 static int svf_quiet
= 0;
231 int svf_register_commands(struct command_context_s
*cmd_ctx
)
233 register_command(cmd_ctx
, NULL
, "svf", handle_svf_command
,
234 COMMAND_EXEC
, "run svf <file>");
239 void svf_free_xxd_para(svf_xxr_para_t
*para
)
243 if (para
->tdi
!= NULL
)
248 if (para
->tdo
!= NULL
)
253 if (para
->mask
!= NULL
)
258 if (para
->smask
!= NULL
)
266 unsigned svf_get_mask_u32(int bitlen
)
274 else if (bitlen
>= 32)
276 bitmask
= 0xFFFFFFFF;
280 bitmask
= (1 << bitlen
) - 1;
286 static const char* tap_state_svf_name(tap_state_t state
)
292 case TAP_RESET
: ret
= "RESET"; break;
293 case TAP_IDLE
: ret
= "IDLE"; break;
294 case TAP_DRSELECT
: ret
= "DRSELECT"; break;
295 case TAP_DRCAPTURE
: ret
= "DRCAPTURE"; break;
296 case TAP_DRSHIFT
: ret
= "DRSHIFT"; break;
297 case TAP_DREXIT1
: ret
= "DREXIT1"; break;
298 case TAP_DRPAUSE
: ret
= "DRPAUSE"; break;
299 case TAP_DREXIT2
: ret
= "DREXIT2"; break;
300 case TAP_DRUPDATE
: ret
= "DRUPDATE"; break;
301 case TAP_IRSELECT
: ret
= "IRSELECT"; break;
302 case TAP_IRCAPTURE
: ret
= "IRCAPTURE"; break;
303 case TAP_IRSHIFT
: ret
= "IRSHIFT"; break;
304 case TAP_IREXIT1
: ret
= "IREXIT1"; break;
305 case TAP_IRPAUSE
: ret
= "IRPAUSE"; break;
306 case TAP_IREXIT2
: ret
= "IREXIT2"; break;
307 case TAP_IRUPDATE
: ret
= "IRUPDATE"; break;
308 default: ret
= "???"; break;
314 static int svf_add_statemove(tap_state_t state_to
)
316 tap_state_t state_from
= cmd_queue_cur_state
;
319 /* when resetting, be paranoid and ignore current state */
320 if (state_to
== TAP_RESET
) {
325 for (index
= 0; index
< dimof(svf_statemoves
); index
++)
327 if ((svf_statemoves
[index
].from
== state_from
)
328 && (svf_statemoves
[index
].to
== state_to
))
330 /* recorded path includes current state ... avoid extra TCKs! */
331 if (svf_statemoves
[index
].num_of_moves
> 1)
332 jtag_add_pathmove(svf_statemoves
[index
].num_of_moves
- 1,
333 svf_statemoves
[index
].paths
+ 1);
335 jtag_add_pathmove(svf_statemoves
[index
].num_of_moves
,
336 svf_statemoves
[index
].paths
);
340 LOG_ERROR("SVF: can not move to %s", tap_state_svf_name(state_to
));
344 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
346 #define SVF_NUM_OF_OPTIONS 1
347 int command_num
= 0, i
;
351 if ((argc
< 1) || (argc
> (1 + SVF_NUM_OF_OPTIONS
)))
353 command_print(cmd_ctx
, "usage: svf <file> [quiet]");
359 for (i
= 1; i
< argc
; i
++)
361 if (!strcmp(args
[i
], "quiet"))
367 LOG_ERROR("unknown variant for svf: %s", args
[i
]);
369 // no need to free anything now
374 if ((svf_fd
= open(args
[0], O_RDONLY
)) < 0)
376 command_print(cmd_ctx
, "file \"%s\" not found", args
[0]);
378 // no need to free anything now
382 LOG_USER("svf processing file: \"%s\"", args
[0]);
385 time_ago
= timeval_ms();
389 svf_command_buffer_size
= 0;
391 svf_check_tdo_para_index
= 0;
392 svf_check_tdo_para
= malloc(sizeof(svf_check_tdo_para_t
) * SVF_CHECK_TDO_PARA_SIZE
);
393 if (NULL
== svf_check_tdo_para
)
395 LOG_ERROR("not enough memory");
400 svf_buffer_index
= 0;
401 // double the buffer size
402 // in case current command cannot be commited, and next command is a bit scan command
403 // here is 32K bits for this big scan command, it should be enough
404 // buffer will be reallocated if buffer size is not enough
405 svf_tdi_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
406 if (NULL
== svf_tdi_buffer
)
408 LOG_ERROR("not enough memory");
412 svf_tdo_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
413 if (NULL
== svf_tdo_buffer
)
415 LOG_ERROR("not enough memory");
419 svf_mask_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
420 if (NULL
== svf_mask_buffer
)
422 LOG_ERROR("not enough memory");
426 svf_buffer_size
= 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
;
428 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
429 for (i
= 0; i
< (int)dimof(svf_tap_state_name
); i
++)
431 svf_tap_state_name
[i
] = (char *)tap_state_svf_name(i
);
437 while (ERROR_OK
== svf_read_command_from_file(svf_fd
))
439 if (ERROR_OK
!= svf_run_command(cmd_ctx
, svf_command_buffer
))
441 LOG_ERROR("fail to run command at line %d", svf_line_number
);
447 if (ERROR_OK
!= jtag_execute_queue())
451 else if (ERROR_OK
!= svf_check_tdo())
457 command_print(cmd_ctx
, "%lld ms used", timeval_ms() - time_ago
);
465 if (svf_command_buffer
)
467 free(svf_command_buffer
);
468 svf_command_buffer
= NULL
;
469 svf_command_buffer_size
= 0;
471 if (svf_check_tdo_para
)
473 free(svf_check_tdo_para
);
474 svf_check_tdo_para
= NULL
;
475 svf_check_tdo_para_index
= 0;
479 free(svf_tdi_buffer
);
480 svf_tdi_buffer
= NULL
;
484 free(svf_tdo_buffer
);
485 svf_tdo_buffer
= NULL
;
489 free(svf_mask_buffer
);
490 svf_mask_buffer
= NULL
;
492 svf_buffer_index
= 0;
495 svf_free_xxd_para(&svf_para
.hdr_para
);
496 svf_free_xxd_para(&svf_para
.hir_para
);
497 svf_free_xxd_para(&svf_para
.tdr_para
);
498 svf_free_xxd_para(&svf_para
.tir_para
);
499 svf_free_xxd_para(&svf_para
.sdr_para
);
500 svf_free_xxd_para(&svf_para
.sir_para
);
504 command_print(cmd_ctx
, "svf file programmed successfully for %d commands", command_num
);
508 command_print(cmd_ctx
, "svf file programmed failed");
514 #define SVFP_CMD_INC_CNT 1024
515 static int svf_read_command_from_file(int fd
)
517 char ch
, *tmp_buffer
= NULL
;
518 int cmd_pos
= 0, cmd_ok
= 0, slash
= 0, comment
= 0;
520 while (!cmd_ok
&& (read(fd
, &ch
, 1) > 0))
550 if (cmd_pos
>= svf_command_buffer_size
- 1)
552 tmp_buffer
= (char*)malloc(svf_command_buffer_size
+ SVFP_CMD_INC_CNT
); // 1 more byte for '\0'
553 if (NULL
== tmp_buffer
)
555 LOG_ERROR("not enough memory");
558 if (svf_command_buffer_size
> 0)
560 memcpy(tmp_buffer
, svf_command_buffer
, svf_command_buffer_size
);
562 if (svf_command_buffer
!= NULL
)
564 free(svf_command_buffer
);
566 svf_command_buffer
= tmp_buffer
;
567 svf_command_buffer_size
+= SVFP_CMD_INC_CNT
;
570 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
578 svf_command_buffer
[cmd_pos
] = '\0';
587 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
589 int pos
= 0, num
= 0, space_found
= 1;
599 LOG_ERROR("fail to parse svf command");
609 argus
[num
++] = &str
[pos
];
622 static int svf_tap_state_is_stable(tap_state_t state
)
624 return ((TAP_RESET
== state
) || (TAP_IDLE
== state
) || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
));
627 static int svf_tap_state_is_valid(tap_state_t state
)
629 return state
>= 0 && state
< TAP_NUM_STATES
;
632 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
636 for (i
= 0; i
< num_of_element
; i
++)
638 if (!strcmp(str
, strs
[i
]))
646 static int svf_adjust_array_length(uint8_t **arr
, int orig_bit_len
, int new_bit_len
)
648 int new_byte_len
= (new_bit_len
+ 7) >> 3;
650 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3)))
657 *arr
= (uint8_t*)malloc(new_byte_len
);
660 LOG_ERROR("not enough memory");
663 memset(*arr
, 0, new_byte_len
);
668 static int svf_copy_hexstring_to_binary(char *str
, uint8_t **bin
, int orig_bit_len
, int bit_len
)
670 int i
, str_len
= strlen(str
), str_hbyte_len
= (bit_len
+ 3) >> 2;
673 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
))
675 LOG_ERROR("fail to adjust length of array");
679 for (i
= 0; i
< str_hbyte_len
; i
++)
688 if ((ch
>= '0') && (ch
<= '9'))
693 else if ((ch
>= 'A') && (ch
<= 'F'))
700 LOG_ERROR("invalid hex string");
712 (*bin
)[i
/ 2] |= ch
<< 4;
723 if (str_len
> 0 || (ch
& ~((1 << (4 - (bit_len
% 4))) - 1)) != 0)
725 LOG_ERROR("value execede length");
732 static int svf_check_tdo(void)
736 for (i
= 0; i
< svf_check_tdo_para_index
; i
++)
738 index
= svf_check_tdo_para
[i
].buffer_offset
;
739 len
= svf_check_tdo_para
[i
].bit_len
;
740 if ((svf_check_tdo_para
[i
].enabled
)
741 && buf_cmp_mask(&svf_tdi_buffer
[index
], &svf_tdo_buffer
[index
], &svf_mask_buffer
[index
], len
))
744 unsigned received
, expected
, tapmask
;
745 bitmask
= svf_get_mask_u32(svf_check_tdo_para
[i
].bit_len
);
747 memcpy(&received
, svf_tdi_buffer
+ index
, sizeof(unsigned));
748 memcpy(&expected
, svf_tdo_buffer
+ index
, sizeof(unsigned));
749 memcpy(&tapmask
, svf_mask_buffer
+ index
, sizeof(unsigned));
750 LOG_ERROR("tdo check error at line %d",
751 svf_check_tdo_para
[i
].line_num
);
752 LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
759 svf_check_tdo_para_index
= 0;
764 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
)
766 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
768 LOG_ERROR("toooooo many operation undone");
772 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
773 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
774 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
775 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
776 svf_check_tdo_para_index
++;
781 static int svf_execute_tap(void)
783 if (ERROR_OK
!= jtag_execute_queue())
787 else if (ERROR_OK
!= svf_check_tdo())
792 svf_buffer_index
= 0;
797 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
)
799 char *argus
[256], command
;
800 int num_of_argu
= 0, i
;
807 float min_time
, max_time
;
809 svf_xxr_para_t
*xxr_para_tmp
;
810 uint8_t **pbuffer_tmp
;
813 tap_state_t
*path
= NULL
, state
;
817 LOG_USER("%s", svf_command_buffer
);
820 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
825 command
= svf_find_string_in_array(argus
[0], (char **)svf_command_name
, dimof(svf_command_name
));
830 if (num_of_argu
!= 2)
832 LOG_ERROR("invalid parameter of %s", argus
[0]);
835 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
836 if (svf_tap_state_is_stable(i_tmp
))
838 if (command
== ENDIR
)
840 svf_para
.ir_end_state
= i_tmp
;
841 LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name
[svf_para
.ir_end_state
]);
845 svf_para
.dr_end_state
= i_tmp
;
846 LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name
[svf_para
.dr_end_state
]);
851 LOG_ERROR("%s is not valid state", argus
[1]);
856 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
858 LOG_ERROR("invalid parameter of %s", argus
[0]);
861 if (1 == num_of_argu
)
863 // TODO: set jtag speed to full speed
864 svf_para
.frequency
= 0;
868 if (strcmp(argus
[2], "HZ"))
870 LOG_ERROR("HZ not found in FREQUENCY command");
873 if (ERROR_OK
!= svf_execute_tap())
877 svf_para
.frequency
= atof(argus
[1]);
878 // TODO: set jtag speed to
879 if (svf_para
.frequency
> 0)
881 command_run_linef(cmd_ctx
, "jtag_khz %d", (int)svf_para
.frequency
/ 1000);
882 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
887 xxr_para_tmp
= &svf_para
.hdr_para
;
890 xxr_para_tmp
= &svf_para
.hir_para
;
893 xxr_para_tmp
= &svf_para
.tdr_para
;
896 xxr_para_tmp
= &svf_para
.tir_para
;
899 xxr_para_tmp
= &svf_para
.sdr_para
;
902 xxr_para_tmp
= &svf_para
.sir_para
;
905 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
906 if ((num_of_argu
> 10) || (num_of_argu
% 2))
908 LOG_ERROR("invalid parameter of %s", argus
[0]);
911 i_tmp
= xxr_para_tmp
->len
;
912 xxr_para_tmp
->len
= atoi(argus
[1]);
913 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
914 xxr_para_tmp
->data_mask
= 0;
915 for (i
= 2; i
< num_of_argu
; i
+= 2)
917 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
919 LOG_ERROR("data section error");
922 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
923 // TDI, TDO, MASK, SMASK
924 if (!strcmp(argus
[i
], "TDI"))
927 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
928 xxr_para_tmp
->data_mask
|= XXR_TDI
;
930 else if (!strcmp(argus
[i
], "TDO"))
933 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
934 xxr_para_tmp
->data_mask
|= XXR_TDO
;
936 else if (!strcmp(argus
[i
], "MASK"))
939 pbuffer_tmp
= &xxr_para_tmp
->mask
;
940 xxr_para_tmp
->data_mask
|= XXR_MASK
;
942 else if (!strcmp(argus
[i
], "SMASK"))
945 pbuffer_tmp
= &xxr_para_tmp
->smask
;
946 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
950 LOG_ERROR("unknow parameter: %s", argus
[i
]);
953 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
955 LOG_ERROR("fail to parse hex value");
958 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & svf_get_mask_u32(xxr_para_tmp
->len
));
960 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
961 // the mask pattern used is all cares
962 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
964 // MASK not defined and length changed
965 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
967 LOG_ERROR("fail to adjust length of array");
970 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
972 // If TDO is absent, no comparison is needed, set the mask to 0
973 if (!(xxr_para_tmp
->data_mask
& XXR_TDO
))
975 if (NULL
== xxr_para_tmp
->tdo
)
977 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->tdo
, i_tmp
, xxr_para_tmp
->len
))
979 LOG_ERROR("fail to adjust length of array");
983 if (NULL
== xxr_para_tmp
->mask
)
985 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
987 LOG_ERROR("fail to adjust length of array");
991 memset(xxr_para_tmp
->mask
, 0, (xxr_para_tmp
->len
+ 7) >> 3);
993 // do scan if necessary
996 // check buffer size first, reallocate if necessary
997 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
998 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1001 // simply print error message
1002 LOG_ERROR("buffer is not enough, report to author");
1005 uint8_t *buffer_tmp
;
1007 // reallocate buffer
1008 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1009 if (NULL
== buffer_tmp
)
1011 LOG_ERROR("not enough memory");
1014 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1015 // svf_tdi_buffer isn't NULL here
1016 free(svf_tdi_buffer
);
1017 svf_tdi_buffer
= buffer_tmp
;
1019 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1020 if (NULL
== buffer_tmp
)
1022 LOG_ERROR("not enough memory");
1025 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1026 // svf_tdo_buffer isn't NULL here
1027 free(svf_tdo_buffer
);
1028 svf_tdo_buffer
= buffer_tmp
;
1030 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1031 if (NULL
== buffer_tmp
)
1033 LOG_ERROR("not enough memory");
1036 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1037 // svf_mask_buffer isn't NULL here
1038 free(svf_mask_buffer
);
1039 svf_mask_buffer
= buffer_tmp
;
1042 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1048 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1049 i
+= svf_para
.hdr_para
.len
;
1050 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1051 i
+= svf_para
.sdr_para
.len
;
1052 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1053 i
+= svf_para
.tdr_para
.len
;
1056 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
1058 // assemble dr mask data
1060 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1061 i
+= svf_para
.hdr_para
.len
;
1062 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1063 i
+= svf_para
.sdr_para
.len
;
1064 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1065 i
+= svf_para
.tdr_para
.len
;
1066 // assemble dr check data
1068 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1069 i
+= svf_para
.hdr_para
.len
;
1070 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1071 i
+= svf_para
.sdr_para
.len
;
1072 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1073 i
+= svf_para
.tdr_para
.len
;
1075 svf_add_check_para(1, svf_buffer_index
, i
);
1079 svf_add_check_para(0, svf_buffer_index
, i
);
1083 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1084 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1085 jtag_add_plain_dr_scan(1, &field
, svf_para
.dr_end_state
);
1087 svf_buffer_index
+= (i
+ 7) >> 3;
1089 else if (SIR
== command
)
1091 // check buffer size first, reallocate if necessary
1092 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
1093 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1096 // simply print error message
1097 LOG_ERROR("buffer is not enough, report to author");
1100 uint8_t *buffer_tmp
;
1102 // reallocate buffer
1103 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1104 if (NULL
== buffer_tmp
)
1106 LOG_ERROR("not enough memory");
1109 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1110 // svf_tdi_buffer isn't NULL here
1111 free(svf_tdi_buffer
);
1112 svf_tdi_buffer
= buffer_tmp
;
1114 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1115 if (NULL
== buffer_tmp
)
1117 LOG_ERROR("not enough memory");
1120 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1121 // svf_tdo_buffer isn't NULL here
1122 free(svf_tdo_buffer
);
1123 svf_tdo_buffer
= buffer_tmp
;
1125 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1126 if (NULL
== buffer_tmp
)
1128 LOG_ERROR("not enough memory");
1131 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1132 // svf_mask_buffer isn't NULL here
1133 free(svf_mask_buffer
);
1134 svf_mask_buffer
= buffer_tmp
;
1137 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1143 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1144 i
+= svf_para
.hir_para
.len
;
1145 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1146 i
+= svf_para
.sir_para
.len
;
1147 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1148 i
+= svf_para
.tir_para
.len
;
1151 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1153 // assemble dr mask data
1155 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1156 i
+= svf_para
.hir_para
.len
;
1157 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1158 i
+= svf_para
.sir_para
.len
;
1159 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1160 i
+= svf_para
.tir_para
.len
;
1161 // assemble dr check data
1163 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1164 i
+= svf_para
.hir_para
.len
;
1165 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1166 i
+= svf_para
.sir_para
.len
;
1167 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1168 i
+= svf_para
.tir_para
.len
;
1170 svf_add_check_para(1, svf_buffer_index
, i
);
1174 svf_add_check_para(0, svf_buffer_index
, i
);
1178 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1179 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1180 jtag_add_plain_ir_scan(1, &field
, svf_para
.ir_end_state
);
1182 svf_buffer_index
+= (i
+ 7) >> 3;
1187 LOG_ERROR("PIO and PIOMAP are not supported");
1191 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1192 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1193 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1195 LOG_ERROR("invalid parameter of %s", argus
[0]);
1204 i_tmp
= svf_find_string_in_array(argus
[i
], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1205 if (svf_tap_state_is_valid(i_tmp
))
1207 if (svf_tap_state_is_stable(i_tmp
))
1209 svf_para
.runtest_run_state
= i_tmp
;
1211 // When a run_state is specified, the new run_state becomes the default end_state
1212 svf_para
.runtest_end_state
= i_tmp
;
1213 LOG_DEBUG("\trun_state = %s", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1218 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1222 // run_count run_clk
1223 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1225 if (!strcmp(argus
[i
+ 1], "TCK"))
1227 // clock source is TCK
1228 run_count
= atoi(argus
[i
]);
1229 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1233 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1239 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1241 min_time
= atof(argus
[i
]);
1242 LOG_DEBUG("\tmin_time = %fs", min_time
);
1245 // MAXIMUM max_time SEC
1246 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1248 max_time
= atof(argus
[i
+ 1]);
1249 LOG_DEBUG("\tmax_time = %fs", max_time
);
1252 // ENDSTATE end_state
1253 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1255 i_tmp
= svf_find_string_in_array(argus
[i
+ 1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1256 if (svf_tap_state_is_stable(i_tmp
))
1258 svf_para
.runtest_end_state
= i_tmp
;
1259 LOG_DEBUG("\tend_state = %s", svf_tap_state_name
[svf_para
.runtest_end_state
]);
1263 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1268 // calculate run_count
1269 if ((0 == run_count
) && (min_time
> 0))
1271 run_count
= min_time
* svf_para
.frequency
;
1273 // all parameter should be parsed
1274 if (i
== num_of_argu
)
1278 // run_state and end_state is checked to be stable state
1281 // enter into run_state if necessary
1282 if (cmd_queue_cur_state
!= svf_para
.runtest_run_state
)
1284 svf_add_statemove(svf_para
.runtest_run_state
);
1287 // call jtag_add_clocks
1288 jtag_add_clocks(run_count
);
1290 // move to end_state if necessary
1291 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1293 svf_add_statemove(svf_para
.runtest_end_state
);
1296 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1298 // RUNTEST can only executed in TAP_IDLE
1299 LOG_ERROR("cannot runtest in %s state", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1303 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1309 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1314 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1315 if (num_of_argu
< 2)
1317 LOG_ERROR("invalid parameter of %s", argus
[0]);
1320 if (num_of_argu
> 2)
1322 // STATE pathstate1 ... stable_state
1323 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1326 LOG_ERROR("not enough memory");
1329 num_of_argu
--; // num of path
1330 i_tmp
= 1; // path is from patameter 1
1331 for (i
= 0; i
< num_of_argu
; i
++)
1333 path
[i
] = svf_find_string_in_array(argus
[i_tmp
++], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1334 if (!svf_tap_state_is_valid(path
[i
]))
1336 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[i
]]);
1340 if (TAP_RESET
== path
[i
])
1344 jtag_add_pathmove(i
, path
);
1347 num_of_argu
-= i
+ 1;
1351 if (num_of_argu
> 0)
1353 // execute last path if necessary
1354 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1356 // last state MUST be stable state
1357 // TODO: call path_move
1358 jtag_add_pathmove(num_of_argu
, path
);
1359 LOG_DEBUG("\tmove to %s by path_move", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1363 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1368 // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1377 // STATE stable_state
1378 state
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1379 if (svf_tap_state_is_stable(state
))
1381 // TODO: move to state
1382 svf_add_statemove(state
);
1384 LOG_DEBUG("\tmove to %s by svf_add_statemove", svf_tap_state_name
[state
]);
1388 LOG_ERROR("%s is not valid state", svf_tap_state_name
[state
]);
1395 if (num_of_argu
!= 2)
1397 LOG_ERROR("invalid parameter of %s", argus
[0]);
1400 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1402 if (ERROR_OK
!= svf_execute_tap())
1406 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_trst_mode_name
, dimof(svf_trst_mode_name
));
1410 jtag_add_reset(1, 0);
1414 jtag_add_reset(0, 0);
1419 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1422 svf_para
.trst_mode
= i_tmp
;
1423 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1427 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1432 LOG_ERROR("invalid svf command: %s", argus
[0]);
1437 if (debug_level
>= LOG_LVL_DEBUG
)
1439 // for convenient debugging, execute tap if possible
1440 if ((svf_buffer_index
> 0) && \
1441 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1442 ((command
== STATE
) && (num_of_argu
== 2))))
1444 if (ERROR_OK
!= svf_execute_tap())
1449 // output debug info
1450 if ((SIR
== command
) || (SDR
== command
))
1453 memcpy(&read_value
, svf_tdi_buffer
, sizeof(int));
1454 // in debug mode, data is from index 0
1455 int read_mask
= svf_get_mask_u32(svf_check_tdo_para
[0].bit_len
);
1456 LOG_DEBUG("\tTDO read = 0x%X", read_value
& read_mask
);
1462 // for fast executing, execute tap if necessary
1463 // half of the buffer is for the next command
1464 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1465 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1466 ((command
== STATE
) && (num_of_argu
== 2))))
1468 return svf_execute_tap();
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)