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 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 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
}}
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 svf_xxr_para_t hir_para
;
164 svf_xxr_para_t hdr_para
;
165 svf_xxr_para_t tir_para
;
166 svf_xxr_para_t tdr_para
;
167 svf_xxr_para_t sir_para
;
168 svf_xxr_para_t sdr_para
;
171 static svf_para_t svf_para
;
172 static const svf_para_t 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
},
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
203 }svf_check_tdo_para_t
;
205 #define SVF_CHECK_TDO_PARA_SIZE 1024
206 static svf_check_tdo_para_t
*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_s
*cmd_ctx
, char *cmd_str
);
213 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
215 static int svf_fd
= 0;
216 static char *svf_command_buffer
= NULL
;
217 static int svf_command_buffer_size
= 0;
218 static int svf_line_number
= 1;
220 static jtag_tap_t
*tap
= NULL
;
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;
228 int svf_register_commands(struct command_context_s
*cmd_ctx
)
230 register_command(cmd_ctx
, NULL
, "svf", handle_svf_command
,
231 COMMAND_EXEC
, "run svf <file>");
236 static void svf_free_xxd_para(svf_xxr_para_t
*para
)
240 if (para
->tdi
!= NULL
)
245 if (para
->tdo
!= NULL
)
250 if (para
->mask
!= NULL
)
255 if (para
->smask
!= NULL
)
263 static unsigned svf_get_mask_u32(int bitlen
)
271 else if (bitlen
>= 32)
273 bitmask
= 0xFFFFFFFF;
277 bitmask
= (1 << bitlen
) - 1;
283 int svf_add_statemove(tap_state_t state_to
)
285 tap_state_t state_from
= cmd_queue_cur_state
;
288 /* when resetting, be paranoid and ignore current state */
289 if (state_to
== TAP_RESET
) {
294 for (index
= 0; index
< DIM(svf_statemoves
); index
++)
296 if ((svf_statemoves
[index
].from
== state_from
)
297 && (svf_statemoves
[index
].to
== state_to
))
299 /* recorded path includes current state ... avoid extra TCKs! */
300 if (svf_statemoves
[index
].num_of_moves
> 1)
301 jtag_add_pathmove(svf_statemoves
[index
].num_of_moves
- 1,
302 svf_statemoves
[index
].paths
+ 1);
304 jtag_add_pathmove(svf_statemoves
[index
].num_of_moves
,
305 svf_statemoves
[index
].paths
);
309 LOG_ERROR("SVF: can not move to %s", tap_state_name(state_to
));
313 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
315 #define SVF_NUM_OF_OPTIONS 1
316 int command_num
= 0, i
;
320 if ((argc
< 1) || (argc
> (1 + SVF_NUM_OF_OPTIONS
)))
322 command_print(cmd_ctx
, "usage: svf <file> [quiet]");
328 for (i
= 1; i
< argc
; i
++)
330 if (!strcmp(args
[i
], "quiet"))
336 LOG_ERROR("unknown variant for svf: %s", args
[i
]);
338 // no need to free anything now
343 if ((svf_fd
= open(args
[0], O_RDONLY
)) < 0)
345 command_print(cmd_ctx
, "file \"%s\" not found", args
[0]);
347 // no need to free anything now
351 LOG_USER("svf processing file: \"%s\"", args
[0]);
354 time_ago
= timeval_ms();
358 svf_command_buffer_size
= 0;
360 svf_check_tdo_para_index
= 0;
361 svf_check_tdo_para
= malloc(sizeof(svf_check_tdo_para_t
) * SVF_CHECK_TDO_PARA_SIZE
);
362 if (NULL
== svf_check_tdo_para
)
364 LOG_ERROR("not enough memory");
369 svf_buffer_index
= 0;
370 // double the buffer size
371 // in case current command cannot be commited, and next command is a bit scan command
372 // here is 32K bits for this big scan command, it should be enough
373 // buffer will be reallocated if buffer size is not enough
374 svf_tdi_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
375 if (NULL
== svf_tdi_buffer
)
377 LOG_ERROR("not enough memory");
381 svf_tdo_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
382 if (NULL
== svf_tdo_buffer
)
384 LOG_ERROR("not enough memory");
388 svf_mask_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
389 if (NULL
== svf_mask_buffer
)
391 LOG_ERROR("not enough memory");
395 svf_buffer_size
= 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
;
397 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
402 while (ERROR_OK
== svf_read_command_from_file(svf_fd
))
404 if (ERROR_OK
!= svf_run_command(cmd_ctx
, svf_command_buffer
))
406 LOG_ERROR("fail to run command at line %d", svf_line_number
);
412 if (ERROR_OK
!= jtag_execute_queue())
416 else if (ERROR_OK
!= svf_check_tdo())
422 command_print(cmd_ctx
, "%lld ms used", timeval_ms() - time_ago
);
430 if (svf_command_buffer
)
432 free(svf_command_buffer
);
433 svf_command_buffer
= NULL
;
434 svf_command_buffer_size
= 0;
436 if (svf_check_tdo_para
)
438 free(svf_check_tdo_para
);
439 svf_check_tdo_para
= NULL
;
440 svf_check_tdo_para_index
= 0;
444 free(svf_tdi_buffer
);
445 svf_tdi_buffer
= NULL
;
449 free(svf_tdo_buffer
);
450 svf_tdo_buffer
= NULL
;
454 free(svf_mask_buffer
);
455 svf_mask_buffer
= NULL
;
457 svf_buffer_index
= 0;
460 svf_free_xxd_para(&svf_para
.hdr_para
);
461 svf_free_xxd_para(&svf_para
.hir_para
);
462 svf_free_xxd_para(&svf_para
.tdr_para
);
463 svf_free_xxd_para(&svf_para
.tir_para
);
464 svf_free_xxd_para(&svf_para
.sdr_para
);
465 svf_free_xxd_para(&svf_para
.sir_para
);
469 command_print(cmd_ctx
, "svf file programmed successfully for %d commands", command_num
);
473 command_print(cmd_ctx
, "svf file programmed failed");
479 #define SVFP_CMD_INC_CNT 1024
480 static int svf_read_command_from_file(int fd
)
482 char ch
, *tmp_buffer
= NULL
;
483 int cmd_pos
= 0, cmd_ok
= 0, slash
= 0, comment
= 0;
485 while (!cmd_ok
&& (read(fd
, &ch
, 1) > 0))
515 if (cmd_pos
>= svf_command_buffer_size
- 1)
517 tmp_buffer
= (char*)malloc(svf_command_buffer_size
+ SVFP_CMD_INC_CNT
); // 1 more byte for '\0'
518 if (NULL
== tmp_buffer
)
520 LOG_ERROR("not enough memory");
523 if (svf_command_buffer_size
> 0)
525 memcpy(tmp_buffer
, svf_command_buffer
, svf_command_buffer_size
);
527 if (svf_command_buffer
!= NULL
)
529 free(svf_command_buffer
);
531 svf_command_buffer
= tmp_buffer
;
532 svf_command_buffer_size
+= SVFP_CMD_INC_CNT
;
535 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
543 svf_command_buffer
[cmd_pos
] = '\0';
552 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
554 int pos
= 0, num
= 0, space_found
= 1;
564 LOG_ERROR("fail to parse svf command");
574 argus
[num
++] = &str
[pos
];
587 bool svf_tap_state_is_stable(tap_state_t state
)
589 return (TAP_RESET
== state
) || (TAP_IDLE
== state
)
590 || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
);
593 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
597 for (i
= 0; i
< num_of_element
; i
++)
599 if (!strcmp(str
, strs
[i
]))
607 static int svf_adjust_array_length(uint8_t **arr
, int orig_bit_len
, int new_bit_len
)
609 int new_byte_len
= (new_bit_len
+ 7) >> 3;
611 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3)))
618 *arr
= (uint8_t*)malloc(new_byte_len
);
621 LOG_ERROR("not enough memory");
624 memset(*arr
, 0, new_byte_len
);
629 static int svf_copy_hexstring_to_binary(char *str
, uint8_t **bin
, int orig_bit_len
, int bit_len
)
631 int i
, str_len
= strlen(str
), str_hbyte_len
= (bit_len
+ 3) >> 2;
634 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
))
636 LOG_ERROR("fail to adjust length of array");
640 for (i
= 0; i
< str_hbyte_len
; i
++)
649 if ((ch
>= '0') && (ch
<= '9'))
654 else if ((ch
>= 'A') && (ch
<= 'F'))
661 LOG_ERROR("invalid hex string");
673 (*bin
)[i
/ 2] |= ch
<< 4;
684 if (str_len
> 0 || (ch
& ~((1 << (4 - (bit_len
% 4))) - 1)) != 0)
686 LOG_ERROR("value execede length");
693 static int svf_check_tdo(void)
697 for (i
= 0; i
< svf_check_tdo_para_index
; i
++)
699 index
= svf_check_tdo_para
[i
].buffer_offset
;
700 len
= svf_check_tdo_para
[i
].bit_len
;
701 if ((svf_check_tdo_para
[i
].enabled
)
702 && buf_cmp_mask(&svf_tdi_buffer
[index
], &svf_tdo_buffer
[index
], &svf_mask_buffer
[index
], len
))
705 unsigned received
, expected
, tapmask
;
706 bitmask
= svf_get_mask_u32(svf_check_tdo_para
[i
].bit_len
);
708 memcpy(&received
, svf_tdi_buffer
+ index
, sizeof(unsigned));
709 memcpy(&expected
, svf_tdo_buffer
+ index
, sizeof(unsigned));
710 memcpy(&tapmask
, svf_mask_buffer
+ index
, sizeof(unsigned));
711 LOG_ERROR("tdo check error at line %d",
712 svf_check_tdo_para
[i
].line_num
);
713 LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
720 svf_check_tdo_para_index
= 0;
725 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
)
727 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
729 LOG_ERROR("toooooo many operation undone");
733 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
734 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
735 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
736 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
737 svf_check_tdo_para_index
++;
742 static int svf_execute_tap(void)
744 if (ERROR_OK
!= jtag_execute_queue())
748 else if (ERROR_OK
!= svf_check_tdo())
753 svf_buffer_index
= 0;
758 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
)
760 char *argus
[256], command
;
761 int num_of_argu
= 0, i
;
768 float min_time
, max_time
;
770 svf_xxr_para_t
*xxr_para_tmp
;
771 uint8_t **pbuffer_tmp
;
774 tap_state_t
*path
= NULL
, state
;
778 LOG_USER("%s", svf_command_buffer
);
781 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
786 /* NOTE: we're a bit loose here, because we ignore case in
787 * TAP state names (instead of insisting on uppercase).
790 command
= svf_find_string_in_array(argus
[0],
791 (char **)svf_command_name
, DIM(svf_command_name
));
796 if (num_of_argu
!= 2)
798 LOG_ERROR("invalid parameter of %s", argus
[0]);
802 i_tmp
= tap_state_by_name(argus
[1]);
804 if (svf_tap_state_is_stable(i_tmp
))
806 if (command
== ENDIR
)
808 svf_para
.ir_end_state
= i_tmp
;
809 LOG_DEBUG("\tIR end_state = %s",
810 tap_state_name(i_tmp
));
814 svf_para
.dr_end_state
= i_tmp
;
815 LOG_DEBUG("\tDR end_state = %s",
816 tap_state_name(i_tmp
));
821 LOG_ERROR("%s: %s is not a stable state",
827 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
829 LOG_ERROR("invalid parameter of %s", argus
[0]);
832 if (1 == num_of_argu
)
834 // TODO: set jtag speed to full speed
835 svf_para
.frequency
= 0;
839 if (strcmp(argus
[2], "HZ"))
841 LOG_ERROR("HZ not found in FREQUENCY command");
844 if (ERROR_OK
!= svf_execute_tap())
848 svf_para
.frequency
= atof(argus
[1]);
849 // TODO: set jtag speed to
850 if (svf_para
.frequency
> 0)
852 command_run_linef(cmd_ctx
, "jtag_khz %d", (int)svf_para
.frequency
/ 1000);
853 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
858 xxr_para_tmp
= &svf_para
.hdr_para
;
861 xxr_para_tmp
= &svf_para
.hir_para
;
864 xxr_para_tmp
= &svf_para
.tdr_para
;
867 xxr_para_tmp
= &svf_para
.tir_para
;
870 xxr_para_tmp
= &svf_para
.sdr_para
;
873 xxr_para_tmp
= &svf_para
.sir_para
;
876 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
877 if ((num_of_argu
> 10) || (num_of_argu
% 2))
879 LOG_ERROR("invalid parameter of %s", argus
[0]);
882 i_tmp
= xxr_para_tmp
->len
;
883 xxr_para_tmp
->len
= atoi(argus
[1]);
884 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
885 xxr_para_tmp
->data_mask
= 0;
886 for (i
= 2; i
< num_of_argu
; i
+= 2)
888 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
890 LOG_ERROR("data section error");
893 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
894 // TDI, TDO, MASK, SMASK
895 if (!strcmp(argus
[i
], "TDI"))
898 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
899 xxr_para_tmp
->data_mask
|= XXR_TDI
;
901 else if (!strcmp(argus
[i
], "TDO"))
904 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
905 xxr_para_tmp
->data_mask
|= XXR_TDO
;
907 else if (!strcmp(argus
[i
], "MASK"))
910 pbuffer_tmp
= &xxr_para_tmp
->mask
;
911 xxr_para_tmp
->data_mask
|= XXR_MASK
;
913 else if (!strcmp(argus
[i
], "SMASK"))
916 pbuffer_tmp
= &xxr_para_tmp
->smask
;
917 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
921 LOG_ERROR("unknow parameter: %s", argus
[i
]);
924 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
926 LOG_ERROR("fail to parse hex value");
929 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & svf_get_mask_u32(xxr_para_tmp
->len
));
931 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
932 // the mask pattern used is all cares
933 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
935 // MASK not defined and length changed
936 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
938 LOG_ERROR("fail to adjust length of array");
941 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
943 // If TDO is absent, no comparison is needed, set the mask to 0
944 if (!(xxr_para_tmp
->data_mask
& XXR_TDO
))
946 if (NULL
== xxr_para_tmp
->tdo
)
948 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->tdo
, i_tmp
, xxr_para_tmp
->len
))
950 LOG_ERROR("fail to adjust length of array");
954 if (NULL
== xxr_para_tmp
->mask
)
956 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
958 LOG_ERROR("fail to adjust length of array");
962 memset(xxr_para_tmp
->mask
, 0, (xxr_para_tmp
->len
+ 7) >> 3);
964 // do scan if necessary
967 // check buffer size first, reallocate if necessary
968 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
969 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
972 // simply print error message
973 LOG_ERROR("buffer is not enough, report to author");
979 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
980 if (NULL
== buffer_tmp
)
982 LOG_ERROR("not enough memory");
985 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
986 // svf_tdi_buffer isn't NULL here
987 free(svf_tdi_buffer
);
988 svf_tdi_buffer
= buffer_tmp
;
990 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
991 if (NULL
== buffer_tmp
)
993 LOG_ERROR("not enough memory");
996 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
997 // svf_tdo_buffer isn't NULL here
998 free(svf_tdo_buffer
);
999 svf_tdo_buffer
= buffer_tmp
;
1001 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1002 if (NULL
== buffer_tmp
)
1004 LOG_ERROR("not enough memory");
1007 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1008 // svf_mask_buffer isn't NULL here
1009 free(svf_mask_buffer
);
1010 svf_mask_buffer
= buffer_tmp
;
1013 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1019 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1020 i
+= svf_para
.hdr_para
.len
;
1021 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1022 i
+= svf_para
.sdr_para
.len
;
1023 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1024 i
+= svf_para
.tdr_para
.len
;
1027 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
1029 // assemble dr mask data
1031 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1032 i
+= svf_para
.hdr_para
.len
;
1033 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1034 i
+= svf_para
.sdr_para
.len
;
1035 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1036 i
+= svf_para
.tdr_para
.len
;
1037 // assemble dr check data
1039 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1040 i
+= svf_para
.hdr_para
.len
;
1041 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1042 i
+= svf_para
.sdr_para
.len
;
1043 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1044 i
+= svf_para
.tdr_para
.len
;
1046 svf_add_check_para(1, svf_buffer_index
, i
);
1050 svf_add_check_para(0, svf_buffer_index
, i
);
1054 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1055 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1056 /* NOTE: doesn't use SVF-specified state paths */
1057 jtag_add_plain_dr_scan(1, &field
, svf_para
.dr_end_state
);
1059 svf_buffer_index
+= (i
+ 7) >> 3;
1061 else if (SIR
== command
)
1063 // check buffer size first, reallocate if necessary
1064 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
1065 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1068 // simply print error message
1069 LOG_ERROR("buffer is not enough, report to author");
1072 uint8_t *buffer_tmp
;
1074 // reallocate buffer
1075 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1076 if (NULL
== buffer_tmp
)
1078 LOG_ERROR("not enough memory");
1081 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1082 // svf_tdi_buffer isn't NULL here
1083 free(svf_tdi_buffer
);
1084 svf_tdi_buffer
= buffer_tmp
;
1086 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1087 if (NULL
== buffer_tmp
)
1089 LOG_ERROR("not enough memory");
1092 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1093 // svf_tdo_buffer isn't NULL here
1094 free(svf_tdo_buffer
);
1095 svf_tdo_buffer
= buffer_tmp
;
1097 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1098 if (NULL
== buffer_tmp
)
1100 LOG_ERROR("not enough memory");
1103 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1104 // svf_mask_buffer isn't NULL here
1105 free(svf_mask_buffer
);
1106 svf_mask_buffer
= buffer_tmp
;
1109 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1115 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1116 i
+= svf_para
.hir_para
.len
;
1117 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1118 i
+= svf_para
.sir_para
.len
;
1119 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1120 i
+= svf_para
.tir_para
.len
;
1123 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1125 // assemble dr mask data
1127 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1128 i
+= svf_para
.hir_para
.len
;
1129 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1130 i
+= svf_para
.sir_para
.len
;
1131 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1132 i
+= svf_para
.tir_para
.len
;
1133 // assemble dr check data
1135 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1136 i
+= svf_para
.hir_para
.len
;
1137 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1138 i
+= svf_para
.sir_para
.len
;
1139 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1140 i
+= svf_para
.tir_para
.len
;
1142 svf_add_check_para(1, svf_buffer_index
, i
);
1146 svf_add_check_para(0, svf_buffer_index
, i
);
1150 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1151 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1152 /* NOTE: doesn't use SVF-specified state paths */
1153 jtag_add_plain_ir_scan(1, &field
, svf_para
.ir_end_state
);
1155 svf_buffer_index
+= (i
+ 7) >> 3;
1160 LOG_ERROR("PIO and PIOMAP are not supported");
1164 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1165 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1166 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1168 LOG_ERROR("invalid parameter of %s", argus
[0]);
1178 i_tmp
= tap_state_by_name(argus
[i
]);
1179 if (i_tmp
!= TAP_INVALID
)
1181 if (svf_tap_state_is_stable(i_tmp
))
1183 svf_para
.runtest_run_state
= i_tmp
;
1185 /* When a run_state is specified, the new
1186 * run_state becomes the default end_state.
1188 svf_para
.runtest_end_state
= i_tmp
;
1189 LOG_DEBUG("\trun_state = %s",
1190 tap_state_name(i_tmp
));
1195 LOG_ERROR("%s: %s is not a stable state",
1196 argus
[0], tap_state_name(i_tmp
));
1201 // run_count run_clk
1202 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1204 if (!strcmp(argus
[i
+ 1], "TCK"))
1206 // clock source is TCK
1207 run_count
= atoi(argus
[i
]);
1208 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1212 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1218 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1220 min_time
= atof(argus
[i
]);
1221 LOG_DEBUG("\tmin_time = %fs", min_time
);
1224 // MAXIMUM max_time SEC
1225 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1227 max_time
= atof(argus
[i
+ 1]);
1228 LOG_DEBUG("\tmax_time = %fs", max_time
);
1231 // ENDSTATE end_state
1232 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1234 i_tmp
= tap_state_by_name(argus
[i
+ 1]);
1236 if (svf_tap_state_is_stable(i_tmp
))
1238 svf_para
.runtest_end_state
= i_tmp
;
1239 LOG_DEBUG("\tend_state = %s",
1240 tap_state_name(i_tmp
));
1244 LOG_ERROR("%s: %s is not a stable state",
1245 argus
[0], tap_state_name(i_tmp
));
1250 // calculate run_count
1251 if ((0 == run_count
) && (min_time
> 0))
1253 run_count
= min_time
* svf_para
.frequency
;
1255 // all parameter should be parsed
1256 if (i
== num_of_argu
)
1260 // run_state and end_state is checked to be stable state
1263 /* FIXME handle statemove failures */
1266 // enter into run_state if necessary
1267 if (cmd_queue_cur_state
!= svf_para
.runtest_run_state
)
1269 retval
= svf_add_statemove(svf_para
.runtest_run_state
);
1272 // call jtag_add_clocks
1273 jtag_add_clocks(run_count
);
1275 // move to end_state if necessary
1276 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1278 retval
= svf_add_statemove(svf_para
.runtest_end_state
);
1281 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1283 LOG_ERROR("cannot runtest in %s state",
1284 tap_state_name(svf_para
.runtest_run_state
));
1288 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1294 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1299 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1300 if (num_of_argu
< 2)
1302 LOG_ERROR("invalid parameter of %s", argus
[0]);
1305 if (num_of_argu
> 2)
1307 // STATE pathstate1 ... stable_state
1308 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1311 LOG_ERROR("not enough memory");
1314 num_of_argu
--; // num of path
1315 i_tmp
= 1; /* path is from parameter 1 */
1316 for (i
= 0; i
< num_of_argu
; i
++, i_tmp
++)
1318 path
[i
] = tap_state_by_name(argus
[i_tmp
]);
1319 if (path
[i
] == TAP_INVALID
)
1321 LOG_ERROR("%s: %s is not a valid state",
1322 argus
[0], argus
[i_tmp
]);
1326 /* OpenOCD refuses paths containing TAP_RESET */
1327 if (TAP_RESET
== path
[i
])
1329 /* FIXME last state MUST be stable! */
1332 jtag_add_pathmove(i
, path
);
1335 num_of_argu
-= i
+ 1;
1339 if (num_of_argu
> 0)
1341 // execute last path if necessary
1342 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1344 // last state MUST be stable state
1345 jtag_add_pathmove(num_of_argu
, path
);
1346 LOG_DEBUG("\tmove to %s by path_move",
1347 tap_state_name(path
[num_of_argu
- 1]));
1351 LOG_ERROR("%s: %s is not a stable state",
1353 tap_state_name(path
[num_of_argu
- 1]));
1358 // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1367 // STATE stable_state
1368 state
= tap_state_by_name(argus
[1]);
1369 if (svf_tap_state_is_stable(state
))
1371 LOG_DEBUG("\tmove to %s by svf_add_statemove",
1372 tap_state_name(state
));
1373 /* FIXME handle statemove failures */
1374 svf_add_statemove(state
);
1378 LOG_ERROR("%s: %s is not a stable state",
1379 argus
[0], tap_state_name(state
));
1386 if (num_of_argu
!= 2)
1388 LOG_ERROR("invalid parameter of %s", argus
[0]);
1391 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1393 if (ERROR_OK
!= svf_execute_tap())
1397 i_tmp
= svf_find_string_in_array(argus
[1],
1398 (char **)svf_trst_mode_name
,
1399 DIM(svf_trst_mode_name
));
1403 jtag_add_reset(1, 0);
1407 jtag_add_reset(0, 0);
1412 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1415 svf_para
.trst_mode
= i_tmp
;
1416 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1420 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1425 LOG_ERROR("invalid svf command: %s", argus
[0]);
1430 if (debug_level
>= LOG_LVL_DEBUG
)
1432 // for convenient debugging, execute tap if possible
1433 if ((svf_buffer_index
> 0) && \
1434 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1435 ((command
== STATE
) && (num_of_argu
== 2))))
1437 if (ERROR_OK
!= svf_execute_tap())
1442 // output debug info
1443 if ((SIR
== command
) || (SDR
== command
))
1446 memcpy(&read_value
, svf_tdi_buffer
, sizeof(int));
1447 // in debug mode, data is from index 0
1448 int read_mask
= svf_get_mask_u32(svf_check_tdo_para
[0].bit_len
);
1449 LOG_DEBUG("\tTDO read = 0x%X", read_value
& read_mask
);
1455 // for fast executing, execute tap if necessary
1456 // half of the buffer is for the next command
1457 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1458 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1459 ((command
== STATE
) && (num_of_argu
== 2))))
1461 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)