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 unsigned bitmask
= (1 << svf_check_tdo_para
[i
].bit_len
) - 1;
657 unsigned received
, expected
, tapmask
;
658 memcpy(&received
, svf_tdi_buffer
+ index
, sizeof(unsigned));
659 memcpy(&expected
, svf_tdo_buffer
+ index
, sizeof(unsigned));
660 memcpy(&tapmask
, svf_mask_buffer
+ index
, sizeof(unsigned));
661 LOG_ERROR("tdo check error at line %d, "
662 "read = 0x%X, want = 0x%X, mask = 0x%X",
663 svf_check_tdo_para
[i
].line_num
,
672 svf_check_tdo_para_index
= 0;
677 static int svf_add_check_para(u8 enabled
, int buffer_offset
, int bit_len
)
679 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
681 LOG_ERROR("toooooo many operation undone");
685 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
686 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
687 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
688 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
689 svf_check_tdo_para_index
++;
694 static int svf_execute_tap(void)
696 if (ERROR_OK
!= jtag_execute_queue())
700 else if (ERROR_OK
!= svf_check_tdo())
705 svf_buffer_index
= 0;
710 // not good to use this
711 extern jtag_command_t
** jtag_get_last_command_p(void);
712 extern void* cmd_queue_alloc(size_t size
);
713 extern jtag_command_t
**last_comand_pointer
;
715 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
)
717 char *argus
[256], command
;
718 int num_of_argu
= 0, i
;
723 // not good to use this
724 jtag_command_t
**last_cmd
;
728 float min_time
, max_time
;
730 svf_xxr_para_t
*xxr_para_tmp
;
734 tap_state_t
*path
= NULL
, state
;
738 LOG_USER("%s", svf_command_buffer
);
741 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
746 command
= svf_find_string_in_array(argus
[0], (char **)svf_command_name
, dimof(svf_command_name
));
751 if (num_of_argu
!= 2)
753 LOG_ERROR("invalid parameter of %s", argus
[0]);
756 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
757 if (svf_tap_state_is_stable(i_tmp
))
759 if (command
== ENDIR
)
761 svf_para
.ir_end_state
= i_tmp
;
762 LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name
[svf_para
.ir_end_state
]);
766 svf_para
.dr_end_state
= i_tmp
;
767 LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name
[svf_para
.dr_end_state
]);
772 LOG_ERROR("%s is not valid state", argus
[1]);
777 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
779 LOG_ERROR("invalid parameter of %s", argus
[0]);
782 if (1 == num_of_argu
)
784 // TODO: set jtag speed to full speed
785 svf_para
.frequency
= 0;
789 if (strcmp(argus
[2], "HZ"))
791 LOG_ERROR("HZ not found in FREQUENCY command");
794 if (ERROR_OK
!= svf_execute_tap())
798 svf_para
.frequency
= atof(argus
[1]);
799 // TODO: set jtag speed to
800 if (svf_para
.frequency
> 0)
802 command_run_linef(cmd_ctx
, "jtag_khz %d", (int)svf_para
.frequency
/ 1000);
803 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
808 xxr_para_tmp
= &svf_para
.hdr_para
;
811 xxr_para_tmp
= &svf_para
.hir_para
;
814 xxr_para_tmp
= &svf_para
.tdr_para
;
817 xxr_para_tmp
= &svf_para
.tir_para
;
820 xxr_para_tmp
= &svf_para
.sdr_para
;
823 xxr_para_tmp
= &svf_para
.sir_para
;
826 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
827 if ((num_of_argu
> 10) || (num_of_argu
% 2))
829 LOG_ERROR("invalid parameter of %s", argus
[0]);
832 i_tmp
= xxr_para_tmp
->len
;
833 xxr_para_tmp
->len
= atoi(argus
[1]);
834 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
835 xxr_para_tmp
->data_mask
= 0;
836 for (i
= 2; i
< num_of_argu
; i
+= 2)
838 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
840 LOG_ERROR("data section error");
843 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
844 // TDI, TDO, MASK, SMASK
845 if (!strcmp(argus
[i
], "TDI"))
848 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
849 xxr_para_tmp
->data_mask
|= XXR_TDI
;
851 else if (!strcmp(argus
[i
], "TDO"))
854 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
855 xxr_para_tmp
->data_mask
|= XXR_TDO
;
857 else if (!strcmp(argus
[i
], "MASK"))
860 pbuffer_tmp
= &xxr_para_tmp
->mask
;
861 xxr_para_tmp
->data_mask
|= XXR_MASK
;
863 else if (!strcmp(argus
[i
], "SMASK"))
866 pbuffer_tmp
= &xxr_para_tmp
->smask
;
867 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
871 LOG_ERROR("unknow parameter: %s", argus
[i
]);
874 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
876 LOG_ERROR("fail to parse hex value");
879 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & ((1 << (xxr_para_tmp
->len
)) - 1));
881 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
882 // the mask pattern used is all cares
883 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
885 // MASK not defined and length changed
886 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
888 LOG_ERROR("fail to adjust length of array");
891 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
893 // do scan if necessary
896 // check buffer size first, reallocate if necessary
897 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
898 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
901 // simply print error message
902 LOG_ERROR("buffer is not enough, report to author");
908 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
909 if (NULL
== buffer_tmp
)
911 LOG_ERROR("not enough memory");
914 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
915 // svf_tdi_buffer isn't NULL here
916 free(svf_tdi_buffer
);
917 svf_tdi_buffer
= buffer_tmp
;
919 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
920 if (NULL
== buffer_tmp
)
922 LOG_ERROR("not enough memory");
925 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
926 // svf_tdo_buffer isn't NULL here
927 free(svf_tdo_buffer
);
928 svf_tdo_buffer
= buffer_tmp
;
930 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
931 if (NULL
== buffer_tmp
)
933 LOG_ERROR("not enough memory");
936 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
937 // svf_mask_buffer isn't NULL here
938 free(svf_mask_buffer
);
939 svf_mask_buffer
= buffer_tmp
;
942 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
948 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
949 i
+= svf_para
.hdr_para
.len
;
950 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
951 i
+= svf_para
.sdr_para
.len
;
952 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
953 i
+= svf_para
.tdr_para
.len
;
956 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
958 // assemble dr mask data
960 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
961 i
+= svf_para
.hdr_para
.len
;
962 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
963 i
+= svf_para
.sdr_para
.len
;
964 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
965 i
+= svf_para
.tdr_para
.len
;
966 // assemble dr check data
968 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
969 i
+= svf_para
.hdr_para
.len
;
970 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
971 i
+= svf_para
.sdr_para
.len
;
972 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
973 i
+= svf_para
.tdr_para
.len
;
975 svf_add_check_para(1, svf_buffer_index
, i
);
979 svf_add_check_para(0, svf_buffer_index
, i
);
983 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
985 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
988 field
.in_handler
= NULL
;
990 jtag_add_plain_dr_scan(1, &field
, svf_para
.dr_end_state
);
992 svf_buffer_index
+= (i
+ 7) >> 3;
993 last_state
= svf_para
.dr_end_state
;
995 else if (SIR
== command
)
997 // check buffer size first, reallocate if necessary
998 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
999 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1002 // simply print error message
1003 LOG_ERROR("buffer is not enough, report to author");
1008 // reallocate buffer
1009 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1010 if (NULL
== buffer_tmp
)
1012 LOG_ERROR("not enough memory");
1015 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1016 // svf_tdi_buffer isn't NULL here
1017 free(svf_tdi_buffer
);
1018 svf_tdi_buffer
= buffer_tmp
;
1020 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1021 if (NULL
== buffer_tmp
)
1023 LOG_ERROR("not enough memory");
1026 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1027 // svf_tdo_buffer isn't NULL here
1028 free(svf_tdo_buffer
);
1029 svf_tdo_buffer
= buffer_tmp
;
1031 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1032 if (NULL
== buffer_tmp
)
1034 LOG_ERROR("not enough memory");
1037 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1038 // svf_mask_buffer isn't NULL here
1039 free(svf_mask_buffer
);
1040 svf_mask_buffer
= buffer_tmp
;
1043 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1049 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1050 i
+= svf_para
.hir_para
.len
;
1051 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1052 i
+= svf_para
.sir_para
.len
;
1053 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1054 i
+= svf_para
.tir_para
.len
;
1057 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1059 // assemble dr mask data
1061 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1062 i
+= svf_para
.hir_para
.len
;
1063 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1064 i
+= svf_para
.sir_para
.len
;
1065 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1066 i
+= svf_para
.tir_para
.len
;
1067 // assemble dr check data
1069 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1070 i
+= svf_para
.hir_para
.len
;
1071 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1072 i
+= svf_para
.sir_para
.len
;
1073 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1074 i
+= svf_para
.tir_para
.len
;
1076 svf_add_check_para(1, svf_buffer_index
, i
);
1080 svf_add_check_para(0, svf_buffer_index
, i
);
1084 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1086 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1089 field
.in_handler
= NULL
;
1091 jtag_add_plain_ir_scan(1, &field
, svf_para
.ir_end_state
);
1093 svf_buffer_index
+= (i
+ 7) >> 3;
1094 last_state
= svf_para
.ir_end_state
;
1099 LOG_ERROR("PIO and PIOMAP are not supported");
1103 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1104 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1105 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1107 LOG_ERROR("invalid parameter of %s", argus
[0]);
1116 i_tmp
= svf_find_string_in_array(argus
[i
], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1117 if (svf_tap_state_is_valid(i_tmp
))
1119 if (svf_tap_state_is_stable(i_tmp
))
1121 svf_para
.runtest_run_state
= i_tmp
;
1123 // When a run_state is specified, the new run_state becomes the default end_state
1124 svf_para
.runtest_end_state
= i_tmp
;
1125 LOG_DEBUG("\trun_state = %s", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1130 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1134 // run_count run_clk
1135 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1137 if (!strcmp(argus
[i
+ 1], "TCK"))
1139 // clock source is TCK
1140 run_count
= atoi(argus
[i
]);
1141 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1145 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1151 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1153 min_time
= atof(argus
[i
]);
1154 LOG_DEBUG("\tmin_time = %fs", min_time
);
1157 // MAXIMUM max_time SEC
1158 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1160 max_time
= atof(argus
[i
+ 1]);
1161 LOG_DEBUG("\tmax_time = %fs", max_time
);
1164 // ENDSTATE end_state
1165 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1167 i_tmp
= svf_find_string_in_array(argus
[i
+ 1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1168 if (svf_tap_state_is_stable(i_tmp
))
1170 svf_para
.runtest_end_state
= i_tmp
;
1171 LOG_DEBUG("\tend_state = %s", svf_tap_state_name
[svf_para
.runtest_end_state
]);
1175 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1180 // calculate run_count
1181 if ((0 == run_count
) && (min_time
> 0))
1183 run_count
= min_time
* svf_para
.frequency
;
1185 // all parameter should be parsed
1186 if (i
== num_of_argu
)
1190 // run_state and end_state is checked to be stable state
1193 // enter into run_state if necessary
1194 if (last_state
!= svf_para
.runtest_run_state
)
1196 last_cmd
= jtag_get_last_command_p();
1197 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1198 last_comand_pointer
= &((*last_cmd
)->next
);
1199 (*last_cmd
)->next
= NULL
;
1200 (*last_cmd
)->type
= JTAG_STATEMOVE
;
1201 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1202 (*last_cmd
)->cmd
.statemove
->end_state
= svf_para
.runtest_run_state
;
1204 cmd_queue_end_state
= cmd_queue_cur_state
= (*last_cmd
)->cmd
.statemove
->end_state
;
1207 // call jtag_add_clocks
1208 jtag_add_clocks(run_count
);
1210 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1212 // move to end_state
1213 last_cmd
= jtag_get_last_command_p();
1214 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1215 last_comand_pointer
= &((*last_cmd
)->next
);
1216 (*last_cmd
)->next
= NULL
;
1217 (*last_cmd
)->type
= JTAG_STATEMOVE
;
1218 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1219 (*last_cmd
)->cmd
.statemove
->end_state
= svf_para
.runtest_end_state
;
1221 cmd_queue_end_state
= cmd_queue_cur_state
= (*last_cmd
)->cmd
.statemove
->end_state
;
1223 last_state
= svf_para
.runtest_end_state
;
1225 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1227 // RUNTEST can only executed in TAP_IDLE
1228 LOG_ERROR("cannot runtest in %s state", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1232 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1238 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1243 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1244 if (num_of_argu
< 2)
1246 LOG_ERROR("invalid parameter of %s", argus
[0]);
1249 if (num_of_argu
> 2)
1251 // STATE pathstate1 ... stable_state
1252 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1255 LOG_ERROR("not enough memory");
1258 num_of_argu
--; // num of path
1259 i_tmp
= 1; // path is from patameter 1
1260 for (i
= 0; i
< num_of_argu
; i
++)
1262 path
[i
] = svf_find_string_in_array(argus
[i_tmp
++], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1263 if (!svf_tap_state_is_valid(path
[i
]))
1265 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[i
]]);
1268 if (TAP_RESET
== path
[i
])
1272 jtag_add_pathmove(i
, path
);
1275 num_of_argu
-= i
+ 1;
1279 if (num_of_argu
> 0)
1281 // execute last path if necessary
1282 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1284 // last state MUST be stable state
1285 // TODO: call path_move
1286 jtag_add_pathmove(num_of_argu
, path
);
1287 last_state
= path
[num_of_argu
- 1];
1288 LOG_DEBUG("\tmove to %s by path_move", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1292 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1296 // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1305 // STATE stable_state
1306 state
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1307 if (svf_tap_state_is_stable(state
))
1309 // TODO: move to state
1310 last_cmd
= jtag_get_last_command_p();
1311 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1312 last_comand_pointer
= &((*last_cmd
)->next
);
1313 (*last_cmd
)->next
= NULL
;
1314 (*last_cmd
)->type
= JTAG_STATEMOVE
;
1315 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1316 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
1318 cmd_queue_end_state
= cmd_queue_cur_state
= (*last_cmd
)->cmd
.statemove
->end_state
;
1321 LOG_DEBUG("\tmove to %s by state_move", svf_tap_state_name
[state
]);
1325 LOG_ERROR("%s is not valid state", svf_tap_state_name
[state
]);
1332 if (num_of_argu
!= 2)
1334 LOG_ERROR("invalid parameter of %s", argus
[0]);
1337 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1339 if (ERROR_OK
!= svf_execute_tap())
1343 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_trst_mode_name
, dimof(svf_trst_mode_name
));
1347 last_state
= TAP_RESET
;
1348 jtag_add_reset(1, 0);
1352 jtag_add_reset(0, 0);
1357 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1360 svf_para
.trst_mode
= i_tmp
;
1361 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1365 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1370 LOG_ERROR("invalid svf command: %s", argus
[0]);
1375 if (debug_level
>= LOG_LVL_DEBUG
)
1377 // for convenient debugging, execute tap if possible
1378 if ((svf_buffer_index
> 0) && \
1379 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1380 ((command
== STATE
) && (num_of_argu
== 2))))
1382 if (ERROR_OK
!= svf_execute_tap())
1387 // output debug info
1388 if ((SIR
== command
) || (SDR
== command
))
1391 memcpy(&read_value
, svf_tdi_buffer
, sizeof(int));
1392 // in debug mode, data is from index 0
1393 int read_mask
= (1 << (svf_check_tdo_para
[0].bit_len
)) - 1;
1394 LOG_DEBUG("\tTDO read = 0x%X", read_value
& read_mask
);
1400 // for fast executing, execute tap if necessary
1401 // half of the buffer is for the next command
1402 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1403 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1404 ((command
== STATE
) && (num_of_argu
== 2))))
1406 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)