1 /***************************************************************************
2 * Copyright (C) 2009 by Simon Qian *
3 * SimonQian@SimonQian.com *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
22 /* The specification for SVF is available here:
23 * http://www.asset-intertech.com/support/svf.pdf
24 * Below, this document is refered to as the "SVF spec".
26 * The specification for XSVF is available here:
27 * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
28 * Below, this document is refered to as the "XSVF spec".
40 #include "time_support.h"
45 #include <sys/types.h>
72 const char *svf_command_name
[14] =
98 const char *svf_trst_mode_name
[4] =
106 char *svf_tap_state_name
[TAP_NUM_STATES
];
108 #define XXR_TDI (1 << 0)
109 #define XXR_TDO (1 << 1)
110 #define XXR_MASK (1 << 2)
111 #define XXR_SMASK (1 << 3)
125 tap_state_t ir_end_state
;
126 tap_state_t dr_end_state
;
127 tap_state_t runtest_run_state
;
128 tap_state_t runtest_end_state
;
129 trst_mode_t trst_mode
;
131 svf_xxr_para_t hir_para
;
132 svf_xxr_para_t hdr_para
;
133 svf_xxr_para_t tir_para
;
134 svf_xxr_para_t tdr_para
;
135 svf_xxr_para_t sir_para
;
136 svf_xxr_para_t sdr_para
;
140 const svf_para_t svf_para_init
=
142 // frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode
143 0, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TRST_Z
,
145 // {len, data_mask, tdi, tdo, mask, smask},
146 {0, 0, NULL
, NULL
, NULL
, NULL
},
148 // {len, data_mask, tdi, tdo, mask, smask},
149 {0, 0, NULL
, NULL
, NULL
, NULL
},
151 // {len, data_mask, tdi, tdo, mask, smask},
152 {0, 0, NULL
, NULL
, NULL
, NULL
},
154 // {len, data_mask, tdi, tdo, mask, smask},
155 {0, 0, NULL
, NULL
, NULL
, NULL
},
157 // {len, data_mask, tdi, tdo, mask, smask},
158 {0, 0, NULL
, NULL
, NULL
, NULL
},
160 // {len, data_mask, tdi, tdo, mask, smask},
161 {0, 0, NULL
, NULL
, NULL
, NULL
},
166 int line_num
; // used to record line number of the check operation
167 // so more information could be printed
168 int enabled
; // check is enabled or not
169 int buffer_offset
; // buffer_offset to buffers
170 int bit_len
; // bit length to check
171 }svf_check_tdo_para_t
;
173 #define SVF_CHECK_TDO_PARA_SIZE 1024
174 static svf_check_tdo_para_t
*svf_check_tdo_para
= NULL
;
175 static int svf_check_tdo_para_index
= 0;
177 #define dimof(a) (sizeof(a) / sizeof((a)[0]))
179 static int svf_read_command_from_file(int fd
);
180 static int svf_check_tdo(void);
181 static int svf_add_check_para(u8 enabled
, int buffer_offset
, int bit_len
);
182 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
);
183 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
185 static int svf_fd
= 0;
186 static char *svf_command_buffer
= NULL
;
187 static int svf_command_buffer_size
= 0;
188 static int svf_line_number
= 1;
190 static jtag_tap_t
*tap
= NULL
;
191 static tap_state_t last_state
= TAP_RESET
;
193 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (4 * 1024)
194 static u8
*svf_tdi_buffer
= NULL
, *svf_tdo_buffer
= NULL
, *svf_mask_buffer
= NULL
;
195 static int svf_buffer_index
= 0, svf_buffer_size
= 0;
196 static int svf_quiet
= 0;
199 int svf_register_commands(struct command_context_s
*cmd_ctx
)
201 register_command(cmd_ctx
, NULL
, "svf", handle_svf_command
,
202 COMMAND_EXEC
, "run svf <file>");
207 void svf_free_xxd_para(svf_xxr_para_t
*para
)
211 if (para
->tdi
!= NULL
)
216 if (para
->tdo
!= NULL
)
221 if (para
->mask
!= NULL
)
226 if (para
->smask
!= NULL
)
234 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
236 #define SVF_NUM_OF_OPTIONS 1
237 int command_num
= 0, i
;
241 if ((argc
< 1) || (argc
> (1 + SVF_NUM_OF_OPTIONS
)))
243 command_print(cmd_ctx
, "usage: svf <file> [quiet]");
249 for (i
= 1; i
< argc
; i
++)
251 if (!strcmp(args
[i
], "quiet"))
257 LOG_ERROR("unknown variant for svf: %s", args
[i
]);
259 // no need to free anything now
264 if ((svf_fd
= open(args
[0], O_RDONLY
)) < 0)
266 command_print(cmd_ctx
, "file \"%s\" not found", args
[0]);
268 // no need to free anything now
272 LOG_USER("svf processing file: \"%s\"", args
[0]);
275 time_ago
= timeval_ms();
279 svf_command_buffer_size
= 0;
281 svf_check_tdo_para_index
= 0;
282 svf_check_tdo_para
= malloc(sizeof(svf_check_tdo_para_t
) * SVF_CHECK_TDO_PARA_SIZE
);
283 if (NULL
== svf_check_tdo_para
)
285 LOG_ERROR("not enough memory");
290 svf_buffer_index
= 0;
291 // double the buffer size
292 // in case current command cannot be commited, and next command is a bit scan command
293 // here is 32K bits for this big scan command, it should be enough
294 // buffer will be reallocated if buffer size is not enough
295 svf_tdi_buffer
= (u8
*)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
296 if (NULL
== svf_tdi_buffer
)
298 LOG_ERROR("not enough memory");
302 svf_tdo_buffer
= (u8
*)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
303 if (NULL
== svf_tdo_buffer
)
305 LOG_ERROR("not enough memory");
309 svf_mask_buffer
= (u8
*)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
310 if (NULL
== svf_mask_buffer
)
312 LOG_ERROR("not enough memory");
316 svf_buffer_size
= 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
;
318 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
319 for (i
= 0; i
< (int)dimof(svf_tap_state_name
); i
++)
321 svf_tap_state_name
[i
] = (char *)tap_state_name(i
);
326 while ( ERROR_OK
== svf_read_command_from_file(svf_fd
) )
328 if (ERROR_OK
!= svf_run_command(cmd_ctx
, svf_command_buffer
))
330 LOG_ERROR("fail to run command at line %d", svf_line_number
);
336 if (ERROR_OK
!= jtag_execute_queue())
340 else if (ERROR_OK
!= svf_check_tdo())
346 command_print(cmd_ctx
, "%d ms used", timeval_ms() - time_ago
);
354 if (svf_command_buffer
)
356 free(svf_command_buffer
);
357 svf_command_buffer
= NULL
;
358 svf_command_buffer_size
= 0;
360 if (svf_check_tdo_para
)
362 free(svf_check_tdo_para
);
363 svf_check_tdo_para
= NULL
;
364 svf_check_tdo_para_index
= 0;
368 free(svf_tdi_buffer
);
369 svf_tdi_buffer
= NULL
;
373 free(svf_tdo_buffer
);
374 svf_tdo_buffer
= NULL
;
378 free(svf_mask_buffer
);
379 svf_mask_buffer
= NULL
;
381 svf_buffer_index
= 0;
384 svf_free_xxd_para(&svf_para
.hdr_para
);
385 svf_free_xxd_para(&svf_para
.hir_para
);
386 svf_free_xxd_para(&svf_para
.tdr_para
);
387 svf_free_xxd_para(&svf_para
.tir_para
);
388 svf_free_xxd_para(&svf_para
.sdr_para
);
389 svf_free_xxd_para(&svf_para
.sir_para
);
393 command_print(cmd_ctx
, "svf file programmed successfully for %d commands", command_num
);
397 command_print(cmd_ctx
, "svf file programmed failed");
403 #define SVFP_CMD_INC_CNT 1024
404 static int svf_read_command_from_file(int fd
)
406 char ch
, *tmp_buffer
= NULL
;
407 int cmd_pos
= 0, cmd_ok
= 0, slash
= 0, comment
= 0;
409 while (!cmd_ok
&& (read(fd
, &ch
, 1) > 0) )
439 if (cmd_pos
>= svf_command_buffer_size
- 1)
441 tmp_buffer
= (char*)malloc(svf_command_buffer_size
+ SVFP_CMD_INC_CNT
); // 1 more byte for '\0'
442 if (NULL
== tmp_buffer
)
444 LOG_ERROR("not enough memory");
447 if (svf_command_buffer_size
> 0)
449 memcpy(tmp_buffer
, svf_command_buffer
, svf_command_buffer_size
);
451 if (svf_command_buffer
!= NULL
)
453 free(svf_command_buffer
);
455 svf_command_buffer
= tmp_buffer
;
456 svf_command_buffer_size
+= SVFP_CMD_INC_CNT
;
459 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
467 svf_command_buffer
[cmd_pos
] = '\0';
476 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
478 int pos
= 0, num
= 0, space_found
= 1;
488 LOG_ERROR("fail to parse svf command");
498 argus
[num
++] = &str
[pos
];
511 static int svf_tap_state_is_stable(tap_state_t state
)
513 return ((TAP_RESET
== state
) || (TAP_IDLE
== state
) || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
));
516 static int svf_tap_state_is_valid(tap_state_t state
)
518 return state
>= 0 && state
< TAP_NUM_STATES
;
521 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
525 for (i
= 0; i
< num_of_element
; i
++)
527 if (!strcmp(str
, strs
[i
]))
535 static int svf_adjust_array_length(u8
**arr
, int orig_bit_len
, int new_bit_len
)
537 int new_byte_len
= (new_bit_len
+ 7) >> 3;
539 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3)))
546 *arr
= (u8
*)malloc(new_byte_len
);
549 LOG_ERROR("not enough memory");
552 memset(*arr
, 0, new_byte_len
);
557 static int svf_copy_hexstring_to_binary(char *str
, u8
**bin
, int orig_bit_len
, int bit_len
)
559 int i
, str_len
= strlen(str
), str_byte_len
= (bit_len
+ 3) >> 2, loop_cnt
;
560 u8 ch
, need_write
= 1;
562 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
))
564 LOG_ERROR("fail to adjust length of array");
568 if (str_byte_len
> str_len
)
570 loop_cnt
= str_byte_len
;
577 for (i
= 0; i
< loop_cnt
; i
++)
581 ch
= str
[str_len
- i
- 1];
582 if ((ch
>= '0') && (ch
<= '9'))
586 else if ((ch
>= 'A') && (ch
<= 'F'))
592 LOG_ERROR("invalid hex string");
602 if (i
>= str_byte_len
)
604 // all data written, other data should be all '0's and needn't to be written
608 LOG_ERROR("value execede length");
612 else if (i
== (str_byte_len
- 1))
614 // last data byte, written if valid
615 if ((ch
& ~((1 << (bit_len
- 4 * i
)) - 1)) != 0)
617 LOG_ERROR("value execede length");
628 (*bin
)[i
/ 2] |= ch
<< 4;
642 static int svf_check_tdo(void)
644 int i
, j
, byte_len
, index
;
646 for (i
= 0; i
< svf_check_tdo_para_index
; i
++)
648 if (svf_check_tdo_para
[i
].enabled
)
650 byte_len
= (svf_check_tdo_para
[i
].bit_len
+ 7) >> 3;
651 index
= svf_check_tdo_para
[i
].buffer_offset
;
652 for (j
= 0; j
< byte_len
; j
++)
654 if ((svf_tdi_buffer
[index
+ j
] & svf_mask_buffer
[index
+ j
]) != svf_tdo_buffer
[index
+ j
])
656 LOG_ERROR("tdo check error at line %d, read = 0x%X, want = 0x%X, mask = 0x%X",
657 svf_check_tdo_para
[i
].line_num
,
658 (*(int*)(svf_tdi_buffer
+ index
)) & ((1 << svf_check_tdo_para
[i
].bit_len
) - 1),
659 (*(int*)(svf_tdo_buffer
+ index
)) & ((1 << svf_check_tdo_para
[i
].bit_len
) - 1),
660 (*(int*)(svf_mask_buffer
+ index
)) & ((1 << svf_check_tdo_para
[i
].bit_len
) - 1));
666 svf_check_tdo_para_index
= 0;
671 static int svf_add_check_para(u8 enabled
, int buffer_offset
, int bit_len
)
673 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
675 LOG_ERROR("toooooo many operation undone");
679 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
680 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
681 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
682 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
683 svf_check_tdo_para_index
++;
688 static int svf_execute_tap(void)
690 if (ERROR_OK
!= jtag_execute_queue())
694 else if (ERROR_OK
!= svf_check_tdo())
699 svf_buffer_index
= 0;
704 // not good to use this
705 extern jtag_command_t
** jtag_get_last_command_p(void);
706 extern void* cmd_queue_alloc(size_t size
);
707 extern jtag_command_t
**last_comand_pointer
;
709 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
)
711 char *argus
[256], command
;
712 int num_of_argu
= 0, i
;
717 // not good to use this
718 jtag_command_t
**last_cmd
;
722 float min_time
, max_time
;
724 svf_xxr_para_t
*xxr_para_tmp
;
728 tap_state_t
*path
= NULL
, state
;
732 LOG_USER("%s", svf_command_buffer
);
735 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
740 command
= svf_find_string_in_array(argus
[0], (char **)svf_command_name
, dimof(svf_command_name
));
745 if (num_of_argu
!= 2)
747 LOG_ERROR("invalid parameter of %s", argus
[0]);
750 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
751 if (svf_tap_state_is_stable(i_tmp
))
753 if (command
== ENDIR
)
755 svf_para
.ir_end_state
= i_tmp
;
756 LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name
[svf_para
.ir_end_state
]);
760 svf_para
.dr_end_state
= i_tmp
;
761 LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name
[svf_para
.dr_end_state
]);
766 LOG_ERROR("%s is not valid state", argus
[1]);
771 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
773 LOG_ERROR("invalid parameter of %s", argus
[0]);
776 if (1 == num_of_argu
)
778 // TODO: set jtag speed to full speed
779 svf_para
.frequency
= 0;
783 if (strcmp(argus
[2], "HZ"))
785 LOG_ERROR("HZ not found in FREQUENCY command");
788 if (ERROR_OK
!= svf_execute_tap())
792 svf_para
.frequency
= atof(argus
[1]);
793 // TODO: set jtag speed to
794 if (svf_para
.frequency
> 0)
796 command_run_linef(cmd_ctx
, "jtag_khz %d", (int)svf_para
.frequency
/ 1000);
797 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
802 xxr_para_tmp
= &svf_para
.hdr_para
;
805 xxr_para_tmp
= &svf_para
.hir_para
;
808 xxr_para_tmp
= &svf_para
.tdr_para
;
811 xxr_para_tmp
= &svf_para
.tir_para
;
814 xxr_para_tmp
= &svf_para
.sdr_para
;
817 xxr_para_tmp
= &svf_para
.sir_para
;
820 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
821 if ((num_of_argu
> 10) || (num_of_argu
% 2))
823 LOG_ERROR("invalid parameter of %s", argus
[0]);
826 i_tmp
= xxr_para_tmp
->len
;
827 xxr_para_tmp
->len
= atoi(argus
[1]);
828 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
829 xxr_para_tmp
->data_mask
= 0;
830 for (i
= 2; i
< num_of_argu
; i
+= 2)
832 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
834 LOG_ERROR("data section error");
837 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
838 // TDI, TDO, MASK, SMASK
839 if (!strcmp(argus
[i
], "TDI"))
842 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
843 xxr_para_tmp
->data_mask
|= XXR_TDI
;
845 else if (!strcmp(argus
[i
], "TDO"))
848 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
849 xxr_para_tmp
->data_mask
|= XXR_TDO
;
851 else if (!strcmp(argus
[i
], "MASK"))
854 pbuffer_tmp
= &xxr_para_tmp
->mask
;
855 xxr_para_tmp
->data_mask
|= XXR_MASK
;
857 else if (!strcmp(argus
[i
], "SMASK"))
860 pbuffer_tmp
= &xxr_para_tmp
->smask
;
861 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
865 LOG_ERROR("unknow parameter: %s", argus
[i
]);
868 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
870 LOG_ERROR("fail to parse hex value");
873 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & ((1 << (xxr_para_tmp
->len
)) - 1));
875 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
876 // the mask pattern used is all cares
877 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
879 // MASK not defined and length changed
880 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
882 LOG_ERROR("fail to adjust length of array");
885 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
887 // do scan if necessary
890 // check buffer size first, reallocate if necessary
891 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
892 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
895 // simply print error message
896 LOG_ERROR("buffer is not enough, report to author");
902 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
903 if (NULL
== buffer_tmp
)
905 LOG_ERROR("not enough memory");
908 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
909 // svf_tdi_buffer isn't NULL here
910 free(svf_tdi_buffer
);
911 svf_tdi_buffer
= buffer_tmp
;
913 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
914 if (NULL
== buffer_tmp
)
916 LOG_ERROR("not enough memory");
919 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
920 // svf_tdo_buffer isn't NULL here
921 free(svf_tdo_buffer
);
922 svf_tdo_buffer
= buffer_tmp
;
924 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
925 if (NULL
== buffer_tmp
)
927 LOG_ERROR("not enough memory");
930 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
931 // svf_mask_buffer isn't NULL here
932 free(svf_mask_buffer
);
933 svf_mask_buffer
= buffer_tmp
;
936 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
942 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
943 i
+= svf_para
.hdr_para
.len
;
944 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
945 i
+= svf_para
.sdr_para
.len
;
946 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
947 i
+= svf_para
.tdr_para
.len
;
950 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
952 // assemble dr mask data
954 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
955 i
+= svf_para
.hdr_para
.len
;
956 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
957 i
+= svf_para
.sdr_para
.len
;
958 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
959 i
+= svf_para
.tdr_para
.len
;
960 // assemble dr check data
962 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
963 i
+= svf_para
.hdr_para
.len
;
964 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
965 i
+= svf_para
.sdr_para
.len
;
966 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
967 i
+= svf_para
.tdr_para
.len
;
969 svf_add_check_para(1, svf_buffer_index
, i
);
973 svf_add_check_para(0, svf_buffer_index
, i
);
977 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
979 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
982 field
.in_handler
= NULL
;
984 jtag_add_plain_dr_scan(1, &field
, svf_para
.dr_end_state
);
986 svf_buffer_index
+= (i
+ 7) >> 3;
987 last_state
= svf_para
.dr_end_state
;
989 else if (SIR
== command
)
991 // check buffer size first, reallocate if necessary
992 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
993 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
996 // simply print error message
997 LOG_ERROR("buffer is not enough, report to author");
1002 // reallocate buffer
1003 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1004 if (NULL
== buffer_tmp
)
1006 LOG_ERROR("not enough memory");
1009 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1010 // svf_tdi_buffer isn't NULL here
1011 free(svf_tdi_buffer
);
1012 svf_tdi_buffer
= buffer_tmp
;
1014 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1015 if (NULL
== buffer_tmp
)
1017 LOG_ERROR("not enough memory");
1020 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1021 // svf_tdo_buffer isn't NULL here
1022 free(svf_tdo_buffer
);
1023 svf_tdo_buffer
= buffer_tmp
;
1025 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1026 if (NULL
== buffer_tmp
)
1028 LOG_ERROR("not enough memory");
1031 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1032 // svf_mask_buffer isn't NULL here
1033 free(svf_mask_buffer
);
1034 svf_mask_buffer
= buffer_tmp
;
1037 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1043 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1044 i
+= svf_para
.hir_para
.len
;
1045 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1046 i
+= svf_para
.sir_para
.len
;
1047 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1048 i
+= svf_para
.tir_para
.len
;
1051 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1053 // assemble dr mask data
1055 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1056 i
+= svf_para
.hir_para
.len
;
1057 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1058 i
+= svf_para
.sir_para
.len
;
1059 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1060 i
+= svf_para
.tir_para
.len
;
1061 // assemble dr check data
1063 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1064 i
+= svf_para
.hir_para
.len
;
1065 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1066 i
+= svf_para
.sir_para
.len
;
1067 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1068 i
+= svf_para
.tir_para
.len
;
1070 svf_add_check_para(1, svf_buffer_index
, i
);
1074 svf_add_check_para(0, svf_buffer_index
, i
);
1078 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1080 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1083 field
.in_handler
= NULL
;
1085 jtag_add_plain_ir_scan(1, &field
, svf_para
.ir_end_state
);
1087 svf_buffer_index
+= (i
+ 7) >> 3;
1088 last_state
= svf_para
.ir_end_state
;
1093 LOG_ERROR("PIO and PIOMAP are not supported");
1097 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1098 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1099 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1101 LOG_ERROR("invalid parameter of %s", argus
[0]);
1110 i_tmp
= svf_find_string_in_array(argus
[i
], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1111 if (svf_tap_state_is_valid(i_tmp
))
1113 if (svf_tap_state_is_stable(i_tmp
))
1115 svf_para
.runtest_run_state
= i_tmp
;
1117 // When a run_state is specified, the new run_state becomes the default end_state
1118 svf_para
.runtest_end_state
= i_tmp
;
1119 LOG_DEBUG("\trun_state = %s", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1124 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1128 // run_count run_clk
1129 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1131 if (!strcmp(argus
[i
+ 1], "TCK"))
1133 // clock source is TCK
1134 run_count
= atoi(argus
[i
]);
1135 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1139 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1145 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1147 min_time
= atof(argus
[i
]);
1148 LOG_DEBUG("\tmin_time = %fs", min_time
);
1151 // MAXIMUM max_time SEC
1152 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1154 max_time
= atof(argus
[i
+ 1]);
1155 LOG_DEBUG("\tmax_time = %fs", max_time
);
1158 // ENDSTATE end_state
1159 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1161 i_tmp
= svf_find_string_in_array(argus
[i
+ 1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1162 if (svf_tap_state_is_stable(i_tmp
))
1164 svf_para
.runtest_end_state
= i_tmp
;
1165 LOG_DEBUG("\tend_state = %s", svf_tap_state_name
[svf_para
.runtest_end_state
]);
1169 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1174 // calculate run_count
1175 if ((0 == run_count
) && (min_time
> 0))
1177 run_count
= min_time
* svf_para
.frequency
;
1179 // all parameter should be parsed
1180 if (i
== num_of_argu
)
1184 // run_state and end_state is checked to be stable state
1187 // enter into run_state if necessary
1188 if (last_state
!= svf_para
.runtest_run_state
)
1190 last_cmd
= jtag_get_last_command_p();
1191 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1192 last_comand_pointer
= &((*last_cmd
)->next
);
1193 (*last_cmd
)->next
= NULL
;
1194 (*last_cmd
)->type
= JTAG_STATEMOVE
;
1195 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1196 (*last_cmd
)->cmd
.statemove
->end_state
= svf_para
.runtest_run_state
;
1198 cmd_queue_end_state
= cmd_queue_cur_state
= (*last_cmd
)->cmd
.statemove
->end_state
;
1201 // call jtag_add_clocks
1202 jtag_add_clocks(run_count
);
1204 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1206 // move to end_state
1207 last_cmd
= jtag_get_last_command_p();
1208 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1209 last_comand_pointer
= &((*last_cmd
)->next
);
1210 (*last_cmd
)->next
= NULL
;
1211 (*last_cmd
)->type
= JTAG_STATEMOVE
;
1212 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1213 (*last_cmd
)->cmd
.statemove
->end_state
= svf_para
.runtest_end_state
;
1215 cmd_queue_end_state
= cmd_queue_cur_state
= (*last_cmd
)->cmd
.statemove
->end_state
;
1217 last_state
= svf_para
.runtest_end_state
;
1219 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1221 // RUNTEST can only executed in TAP_IDLE
1222 LOG_ERROR("cannot runtest in %s state", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1226 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1232 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1237 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1238 if (num_of_argu
< 2)
1240 LOG_ERROR("invalid parameter of %s", argus
[0]);
1243 if (num_of_argu
> 2)
1245 // STATE pathstate1 ... stable_state
1246 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1249 LOG_ERROR("not enough memory");
1252 num_of_argu
--; // num of path
1253 i_tmp
= 1; // path is from patameter 1
1254 for (i
= 0; i
< num_of_argu
; i
++)
1256 path
[i
] = svf_find_string_in_array(argus
[i_tmp
++], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1257 if (!svf_tap_state_is_valid(path
[i
]))
1259 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[i
]]);
1262 if (TAP_RESET
== path
[i
])
1266 jtag_add_pathmove(i
, path
);
1269 num_of_argu
-= i
+ 1;
1273 if (num_of_argu
> 0)
1275 // execute last path if necessary
1276 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1278 // last state MUST be stable state
1279 // TODO: call path_move
1280 jtag_add_pathmove(num_of_argu
, path
);
1281 last_state
= path
[num_of_argu
- 1];
1282 LOG_DEBUG("\tmove to %s by path_move", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1286 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1290 // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1299 // STATE stable_state
1300 state
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1301 if (svf_tap_state_is_stable(state
))
1303 // TODO: move to state
1304 last_cmd
= jtag_get_last_command_p();
1305 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1306 last_comand_pointer
= &((*last_cmd
)->next
);
1307 (*last_cmd
)->next
= NULL
;
1308 (*last_cmd
)->type
= JTAG_STATEMOVE
;
1309 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1310 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
1312 cmd_queue_end_state
= cmd_queue_cur_state
= (*last_cmd
)->cmd
.statemove
->end_state
;
1315 LOG_DEBUG("\tmove to %s by state_move", svf_tap_state_name
[state
]);
1319 LOG_ERROR("%s is not valid state", svf_tap_state_name
[state
]);
1326 if (num_of_argu
!= 2)
1328 LOG_ERROR("invalid parameter of %s", argus
[0]);
1331 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1333 if (ERROR_OK
!= svf_execute_tap())
1337 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_trst_mode_name
, dimof(svf_trst_mode_name
));
1341 last_state
= TAP_RESET
;
1342 jtag_add_reset(1, 0);
1346 jtag_add_reset(0, 0);
1351 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1354 svf_para
.trst_mode
= i_tmp
;
1355 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1359 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1364 LOG_ERROR("invalid svf command: %s", argus
[0]);
1369 if (debug_level
>= LOG_LVL_DEBUG
)
1371 // for convenient debugging, execute tap if possible
1372 if ((svf_buffer_index
> 0) && \
1373 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1374 ((command
== STATE
) && (num_of_argu
== 2))))
1376 if (ERROR_OK
!= svf_execute_tap())
1381 // output debug info
1382 if ((SIR
== command
) || (SDR
== command
))
1384 // in debug mode, data is from index 0
1385 LOG_DEBUG("\tTDO read = 0x%X", (*(int*)svf_tdi_buffer
) & ((1 << (svf_check_tdo_para
[0].bit_len
)) - 1));
1391 // for fast executing, execute tap if necessary
1392 // half of the buffer is for the next command
1393 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1394 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1395 ((command
== STATE
) && (num_of_argu
== 2))))
1397 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)