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".
37 #include "time_support.h"
59 const char *svf_command_name
[14] =
85 const char *svf_trst_mode_name
[4] =
93 char *svf_tap_state_name
[TAP_NUM_STATES
];
95 #define XXR_TDI (1 << 0)
96 #define XXR_TDO (1 << 1)
97 #define XXR_MASK (1 << 2)
98 #define XXR_SMASK (1 << 3)
112 tap_state_t ir_end_state
;
113 tap_state_t dr_end_state
;
114 tap_state_t runtest_run_state
;
115 tap_state_t runtest_end_state
;
116 trst_mode_t trst_mode
;
118 svf_xxr_para_t hir_para
;
119 svf_xxr_para_t hdr_para
;
120 svf_xxr_para_t tir_para
;
121 svf_xxr_para_t tdr_para
;
122 svf_xxr_para_t sir_para
;
123 svf_xxr_para_t sdr_para
;
127 const svf_para_t svf_para_init
=
129 // frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode
130 0, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TRST_Z
,
132 // {len, data_mask, tdi, tdo, mask, smask},
133 {0, 0, NULL
, NULL
, NULL
, NULL
},
135 // {len, data_mask, tdi, tdo, mask, smask},
136 {0, 0, NULL
, NULL
, NULL
, NULL
},
138 // {len, data_mask, tdi, tdo, mask, smask},
139 {0, 0, NULL
, NULL
, NULL
, NULL
},
141 // {len, data_mask, tdi, tdo, mask, smask},
142 {0, 0, NULL
, NULL
, NULL
, NULL
},
144 // {len, data_mask, tdi, tdo, mask, smask},
145 {0, 0, NULL
, NULL
, NULL
, NULL
},
147 // {len, data_mask, tdi, tdo, mask, smask},
148 {0, 0, NULL
, NULL
, NULL
, NULL
},
153 int line_num
; // used to record line number of the check operation
154 // so more information could be printed
155 int enabled
; // check is enabled or not
156 int buffer_offset
; // buffer_offset to buffers
157 int bit_len
; // bit length to check
158 }svf_check_tdo_para_t
;
160 #define SVF_CHECK_TDO_PARA_SIZE 1024
161 static svf_check_tdo_para_t
*svf_check_tdo_para
= NULL
;
162 static int svf_check_tdo_para_index
= 0;
164 #define dimof(a) (sizeof(a) / sizeof((a)[0]))
166 static int svf_read_command_from_file(int fd
);
167 static int svf_check_tdo(void);
168 static int svf_add_check_para(u8 enabled
, int buffer_offset
, int bit_len
);
169 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
);
170 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
172 static int svf_fd
= 0;
173 static char *svf_command_buffer
= NULL
;
174 static int svf_command_buffer_size
= 0;
175 static int svf_line_number
= 1;
177 static jtag_tap_t
*tap
= NULL
;
178 static tap_state_t last_state
= TAP_RESET
;
180 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (4 * 1024)
181 static u8
*svf_tdi_buffer
= NULL
, *svf_tdo_buffer
= NULL
, *svf_mask_buffer
= NULL
;
182 static int svf_buffer_index
= 0, svf_buffer_size
= 0;
183 static int svf_quiet
= 0;
186 int svf_register_commands(struct command_context_s
*cmd_ctx
)
188 register_command(cmd_ctx
, NULL
, "svf", handle_svf_command
,
189 COMMAND_EXEC
, "run svf <file>");
194 void svf_free_xxd_para(svf_xxr_para_t
*para
)
198 if (para
->tdi
!= NULL
)
203 if (para
->tdo
!= NULL
)
208 if (para
->mask
!= NULL
)
213 if (para
->smask
!= NULL
)
221 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
223 #define SVF_NUM_OF_OPTIONS 1
224 int command_num
= 0, i
;
228 if ((argc
< 1) || (argc
> (1 + SVF_NUM_OF_OPTIONS
)))
230 command_print(cmd_ctx
, "usage: svf <file> [quiet]");
236 for (i
= 1; i
< argc
; i
++)
238 if (!strcmp(args
[i
], "quiet"))
244 LOG_ERROR("unknown variant for svf: %s", args
[i
]);
246 // no need to free anything now
251 if ((svf_fd
= open(args
[0], O_RDONLY
)) < 0)
253 command_print(cmd_ctx
, "file \"%s\" not found", args
[0]);
255 // no need to free anything now
259 LOG_USER("svf processing file: \"%s\"", args
[0]);
262 time_ago
= timeval_ms();
266 svf_command_buffer_size
= 0;
268 svf_check_tdo_para_index
= 0;
269 svf_check_tdo_para
= malloc(sizeof(svf_check_tdo_para_t
) * SVF_CHECK_TDO_PARA_SIZE
);
270 if (NULL
== svf_check_tdo_para
)
272 LOG_ERROR("not enough memory");
277 svf_buffer_index
= 0;
278 // double the buffer size
279 // in case current command cannot be commited, and next command is a bit scan command
280 // here is 32K bits for this big scan command, it should be enough
281 // buffer will be reallocated if buffer size is not enough
282 svf_tdi_buffer
= (u8
*)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
283 if (NULL
== svf_tdi_buffer
)
285 LOG_ERROR("not enough memory");
289 svf_tdo_buffer
= (u8
*)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
290 if (NULL
== svf_tdo_buffer
)
292 LOG_ERROR("not enough memory");
296 svf_mask_buffer
= (u8
*)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
297 if (NULL
== svf_mask_buffer
)
299 LOG_ERROR("not enough memory");
303 svf_buffer_size
= 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
;
305 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
306 for (i
= 0; i
< (int)dimof(svf_tap_state_name
); i
++)
308 svf_tap_state_name
[i
] = (char *)tap_state_name(i
);
313 while ( ERROR_OK
== svf_read_command_from_file(svf_fd
) )
315 if (ERROR_OK
!= svf_run_command(cmd_ctx
, svf_command_buffer
))
317 LOG_ERROR("fail to run command at line %d", svf_line_number
);
323 if (ERROR_OK
!= jtag_execute_queue())
327 else if (ERROR_OK
!= svf_check_tdo())
333 command_print(cmd_ctx
, "%d ms used", timeval_ms() - time_ago
);
341 if (svf_command_buffer
)
343 free(svf_command_buffer
);
344 svf_command_buffer
= NULL
;
345 svf_command_buffer_size
= 0;
347 if (svf_check_tdo_para
)
349 free(svf_check_tdo_para
);
350 svf_check_tdo_para
= NULL
;
351 svf_check_tdo_para_index
= 0;
355 free(svf_tdi_buffer
);
356 svf_tdi_buffer
= NULL
;
360 free(svf_tdo_buffer
);
361 svf_tdo_buffer
= NULL
;
365 free(svf_mask_buffer
);
366 svf_mask_buffer
= NULL
;
368 svf_buffer_index
= 0;
371 svf_free_xxd_para(&svf_para
.hdr_para
);
372 svf_free_xxd_para(&svf_para
.hir_para
);
373 svf_free_xxd_para(&svf_para
.tdr_para
);
374 svf_free_xxd_para(&svf_para
.tir_para
);
375 svf_free_xxd_para(&svf_para
.sdr_para
);
376 svf_free_xxd_para(&svf_para
.sir_para
);
380 command_print(cmd_ctx
, "svf file programmed successfully for %d commands", command_num
);
384 command_print(cmd_ctx
, "svf file programmed failed");
390 #define SVFP_CMD_INC_CNT 1024
391 static int svf_read_command_from_file(int fd
)
393 char ch
, *tmp_buffer
= NULL
;
394 int cmd_pos
= 0, cmd_ok
= 0, slash
= 0, comment
= 0;
396 while (!cmd_ok
&& (read(fd
, &ch
, 1) > 0) )
426 if (cmd_pos
>= svf_command_buffer_size
- 1)
428 tmp_buffer
= (char*)malloc(svf_command_buffer_size
+ SVFP_CMD_INC_CNT
); // 1 more byte for '\0'
429 if (NULL
== tmp_buffer
)
431 LOG_ERROR("not enough memory");
434 if (svf_command_buffer_size
> 0)
436 memcpy(tmp_buffer
, svf_command_buffer
, svf_command_buffer_size
);
438 if (svf_command_buffer
!= NULL
)
440 free(svf_command_buffer
);
442 svf_command_buffer
= tmp_buffer
;
443 svf_command_buffer_size
+= SVFP_CMD_INC_CNT
;
446 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
454 svf_command_buffer
[cmd_pos
] = '\0';
463 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
465 int pos
= 0, num
= 0, space_found
= 1;
475 LOG_ERROR("fail to parse svf command");
485 argus
[num
++] = &str
[pos
];
498 static int svf_tap_state_is_stable(tap_state_t state
)
500 return ((TAP_RESET
== state
) || (TAP_IDLE
== state
) || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
));
503 static int svf_tap_state_is_valid(tap_state_t state
)
505 return state
>= 0 && state
< TAP_NUM_STATES
;
508 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
512 for (i
= 0; i
< num_of_element
; i
++)
514 if (!strcmp(str
, strs
[i
]))
522 static int svf_adjust_array_length(u8
**arr
, int orig_bit_len
, int new_bit_len
)
524 int new_byte_len
= (new_bit_len
+ 7) >> 3;
526 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3)))
533 *arr
= (u8
*)malloc(new_byte_len
);
536 LOG_ERROR("not enough memory");
539 memset(*arr
, 0, new_byte_len
);
544 static int svf_copy_hexstring_to_binary(char *str
, u8
**bin
, int orig_bit_len
, int bit_len
)
546 int i
, str_len
= strlen(str
), str_byte_len
= (bit_len
+ 3) >> 2, loop_cnt
;
547 u8 ch
, need_write
= 1;
549 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
))
551 LOG_ERROR("fail to adjust length of array");
555 if (str_byte_len
> str_len
)
557 loop_cnt
= str_byte_len
;
564 for (i
= 0; i
< loop_cnt
; i
++)
568 ch
= str
[str_len
- i
- 1];
569 if ((ch
>= '0') && (ch
<= '9'))
573 else if ((ch
>= 'A') && (ch
<= 'F'))
579 LOG_ERROR("invalid hex string");
589 if (i
>= str_byte_len
)
591 // all data written, other data should be all '0's and needn't to be written
595 LOG_ERROR("value execede length");
599 else if (i
== (str_byte_len
- 1))
601 // last data byte, written if valid
602 if ((ch
& ~((1 << (bit_len
- 4 * i
)) - 1)) != 0)
604 LOG_ERROR("value execede length");
615 (*bin
)[i
/ 2] |= ch
<< 4;
629 static int svf_check_tdo(void)
631 int i
, j
, byte_len
, index
;
633 for (i
= 0; i
< svf_check_tdo_para_index
; i
++)
635 if (svf_check_tdo_para
[i
].enabled
)
637 byte_len
= (svf_check_tdo_para
[i
].bit_len
+ 7) >> 3;
638 index
= svf_check_tdo_para
[i
].buffer_offset
;
639 for (j
= 0; j
< byte_len
; j
++)
641 if ((svf_tdi_buffer
[index
+ j
] & svf_mask_buffer
[index
+ j
]) != svf_tdo_buffer
[index
+ j
])
643 unsigned bitmask
= (1 << svf_check_tdo_para
[i
].bit_len
) - 1;
644 unsigned received
, expected
, tapmask
;
645 memcpy(&received
, svf_tdi_buffer
+ index
, sizeof(unsigned));
646 memcpy(&expected
, svf_tdo_buffer
+ index
, sizeof(unsigned));
647 memcpy(&tapmask
, svf_mask_buffer
+ index
, sizeof(unsigned));
648 LOG_ERROR("tdo check error at line %d, "
649 "read = 0x%X, want = 0x%X, mask = 0x%X",
650 svf_check_tdo_para
[i
].line_num
,
659 svf_check_tdo_para_index
= 0;
664 static int svf_add_check_para(u8 enabled
, int buffer_offset
, int bit_len
)
666 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
668 LOG_ERROR("toooooo many operation undone");
672 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
673 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
674 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
675 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
676 svf_check_tdo_para_index
++;
681 static int svf_execute_tap(void)
683 if (ERROR_OK
!= jtag_execute_queue())
687 else if (ERROR_OK
!= svf_check_tdo())
692 svf_buffer_index
= 0;
697 // not good to use this
698 extern void* cmd_queue_alloc(size_t size
);
699 extern void jtag_queue_command(jtag_command_t
* cmd
);
701 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
)
703 char *argus
[256], command
;
704 int num_of_argu
= 0, i
;
711 float min_time
, max_time
;
713 svf_xxr_para_t
*xxr_para_tmp
;
717 tap_state_t
*path
= NULL
, state
;
721 LOG_USER("%s", svf_command_buffer
);
724 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
729 command
= svf_find_string_in_array(argus
[0], (char **)svf_command_name
, dimof(svf_command_name
));
734 if (num_of_argu
!= 2)
736 LOG_ERROR("invalid parameter of %s", argus
[0]);
739 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
740 if (svf_tap_state_is_stable(i_tmp
))
742 if (command
== ENDIR
)
744 svf_para
.ir_end_state
= i_tmp
;
745 LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name
[svf_para
.ir_end_state
]);
749 svf_para
.dr_end_state
= i_tmp
;
750 LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name
[svf_para
.dr_end_state
]);
755 LOG_ERROR("%s is not valid state", argus
[1]);
760 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
762 LOG_ERROR("invalid parameter of %s", argus
[0]);
765 if (1 == num_of_argu
)
767 // TODO: set jtag speed to full speed
768 svf_para
.frequency
= 0;
772 if (strcmp(argus
[2], "HZ"))
774 LOG_ERROR("HZ not found in FREQUENCY command");
777 if (ERROR_OK
!= svf_execute_tap())
781 svf_para
.frequency
= atof(argus
[1]);
782 // TODO: set jtag speed to
783 if (svf_para
.frequency
> 0)
785 command_run_linef(cmd_ctx
, "jtag_khz %d", (int)svf_para
.frequency
/ 1000);
786 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
791 xxr_para_tmp
= &svf_para
.hdr_para
;
794 xxr_para_tmp
= &svf_para
.hir_para
;
797 xxr_para_tmp
= &svf_para
.tdr_para
;
800 xxr_para_tmp
= &svf_para
.tir_para
;
803 xxr_para_tmp
= &svf_para
.sdr_para
;
806 xxr_para_tmp
= &svf_para
.sir_para
;
809 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
810 if ((num_of_argu
> 10) || (num_of_argu
% 2))
812 LOG_ERROR("invalid parameter of %s", argus
[0]);
815 i_tmp
= xxr_para_tmp
->len
;
816 xxr_para_tmp
->len
= atoi(argus
[1]);
817 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
818 xxr_para_tmp
->data_mask
= 0;
819 for (i
= 2; i
< num_of_argu
; i
+= 2)
821 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
823 LOG_ERROR("data section error");
826 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
827 // TDI, TDO, MASK, SMASK
828 if (!strcmp(argus
[i
], "TDI"))
831 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
832 xxr_para_tmp
->data_mask
|= XXR_TDI
;
834 else if (!strcmp(argus
[i
], "TDO"))
837 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
838 xxr_para_tmp
->data_mask
|= XXR_TDO
;
840 else if (!strcmp(argus
[i
], "MASK"))
843 pbuffer_tmp
= &xxr_para_tmp
->mask
;
844 xxr_para_tmp
->data_mask
|= XXR_MASK
;
846 else if (!strcmp(argus
[i
], "SMASK"))
849 pbuffer_tmp
= &xxr_para_tmp
->smask
;
850 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
854 LOG_ERROR("unknow parameter: %s", argus
[i
]);
857 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
859 LOG_ERROR("fail to parse hex value");
862 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & ((1 << (xxr_para_tmp
->len
)) - 1));
864 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
865 // the mask pattern used is all cares
866 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
868 // MASK not defined and length changed
869 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
871 LOG_ERROR("fail to adjust length of array");
874 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
876 // do scan if necessary
879 // check buffer size first, reallocate if necessary
880 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
881 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
884 // simply print error message
885 LOG_ERROR("buffer is not enough, report to author");
891 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
892 if (NULL
== buffer_tmp
)
894 LOG_ERROR("not enough memory");
897 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
898 // svf_tdi_buffer isn't NULL here
899 free(svf_tdi_buffer
);
900 svf_tdi_buffer
= buffer_tmp
;
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_tdo_buffer
, svf_buffer_index
);
909 // svf_tdo_buffer isn't NULL here
910 free(svf_tdo_buffer
);
911 svf_tdo_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_mask_buffer
, svf_buffer_index
);
920 // svf_mask_buffer isn't NULL here
921 free(svf_mask_buffer
);
922 svf_mask_buffer
= buffer_tmp
;
925 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
931 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
932 i
+= svf_para
.hdr_para
.len
;
933 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
934 i
+= svf_para
.sdr_para
.len
;
935 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
936 i
+= svf_para
.tdr_para
.len
;
939 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
941 // assemble dr mask data
943 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
944 i
+= svf_para
.hdr_para
.len
;
945 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
946 i
+= svf_para
.sdr_para
.len
;
947 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
948 i
+= svf_para
.tdr_para
.len
;
949 // assemble dr check data
951 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
952 i
+= svf_para
.hdr_para
.len
;
953 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
954 i
+= svf_para
.sdr_para
.len
;
955 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
956 i
+= svf_para
.tdr_para
.len
;
958 svf_add_check_para(1, svf_buffer_index
, i
);
962 svf_add_check_para(0, svf_buffer_index
, i
);
966 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
968 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
973 jtag_add_plain_dr_scan(1, &field
, svf_para
.dr_end_state
);
975 svf_buffer_index
+= (i
+ 7) >> 3;
976 last_state
= svf_para
.dr_end_state
;
978 else if (SIR
== command
)
980 // check buffer size first, reallocate if necessary
981 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
982 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
985 // simply print error message
986 LOG_ERROR("buffer is not enough, report to author");
992 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
993 if (NULL
== buffer_tmp
)
995 LOG_ERROR("not enough memory");
998 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
999 // svf_tdi_buffer isn't NULL here
1000 free(svf_tdi_buffer
);
1001 svf_tdi_buffer
= buffer_tmp
;
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_tdo_buffer
, svf_buffer_index
);
1010 // svf_tdo_buffer isn't NULL here
1011 free(svf_tdo_buffer
);
1012 svf_tdo_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_mask_buffer
, svf_buffer_index
);
1021 // svf_mask_buffer isn't NULL here
1022 free(svf_mask_buffer
);
1023 svf_mask_buffer
= buffer_tmp
;
1026 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1032 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1033 i
+= svf_para
.hir_para
.len
;
1034 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1035 i
+= svf_para
.sir_para
.len
;
1036 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1037 i
+= svf_para
.tir_para
.len
;
1040 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1042 // assemble dr mask data
1044 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1045 i
+= svf_para
.hir_para
.len
;
1046 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1047 i
+= svf_para
.sir_para
.len
;
1048 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1049 i
+= svf_para
.tir_para
.len
;
1050 // assemble dr check data
1052 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1053 i
+= svf_para
.hir_para
.len
;
1054 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1055 i
+= svf_para
.sir_para
.len
;
1056 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1057 i
+= svf_para
.tir_para
.len
;
1059 svf_add_check_para(1, svf_buffer_index
, i
);
1063 svf_add_check_para(0, svf_buffer_index
, i
);
1067 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1069 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1074 jtag_add_plain_ir_scan(1, &field
, svf_para
.ir_end_state
);
1076 svf_buffer_index
+= (i
+ 7) >> 3;
1077 last_state
= svf_para
.ir_end_state
;
1082 LOG_ERROR("PIO and PIOMAP are not supported");
1086 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1087 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1088 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1090 LOG_ERROR("invalid parameter of %s", argus
[0]);
1099 i_tmp
= svf_find_string_in_array(argus
[i
], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1100 if (svf_tap_state_is_valid(i_tmp
))
1102 if (svf_tap_state_is_stable(i_tmp
))
1104 svf_para
.runtest_run_state
= i_tmp
;
1106 // When a run_state is specified, the new run_state becomes the default end_state
1107 svf_para
.runtest_end_state
= i_tmp
;
1108 LOG_DEBUG("\trun_state = %s", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1113 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1117 // run_count run_clk
1118 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1120 if (!strcmp(argus
[i
+ 1], "TCK"))
1122 // clock source is TCK
1123 run_count
= atoi(argus
[i
]);
1124 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1128 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1134 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1136 min_time
= atof(argus
[i
]);
1137 LOG_DEBUG("\tmin_time = %fs", min_time
);
1140 // MAXIMUM max_time SEC
1141 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1143 max_time
= atof(argus
[i
+ 1]);
1144 LOG_DEBUG("\tmax_time = %fs", max_time
);
1147 // ENDSTATE end_state
1148 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1150 i_tmp
= svf_find_string_in_array(argus
[i
+ 1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1151 if (svf_tap_state_is_stable(i_tmp
))
1153 svf_para
.runtest_end_state
= i_tmp
;
1154 LOG_DEBUG("\tend_state = %s", svf_tap_state_name
[svf_para
.runtest_end_state
]);
1158 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1163 // calculate run_count
1164 if ((0 == run_count
) && (min_time
> 0))
1166 run_count
= min_time
* svf_para
.frequency
;
1168 // all parameter should be parsed
1169 if (i
== num_of_argu
)
1173 // run_state and end_state is checked to be stable state
1176 // enter into run_state if necessary
1177 if (last_state
!= svf_para
.runtest_run_state
)
1179 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1181 jtag_queue_command(cmd
);
1183 cmd
->type
= JTAG_STATEMOVE
;
1184 cmd
->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1185 cmd
->cmd
.statemove
->end_state
= svf_para
.runtest_run_state
;
1187 cmd_queue_end_state
= cmd_queue_cur_state
= cmd
->cmd
.statemove
->end_state
;
1190 // call jtag_add_clocks
1191 jtag_add_clocks(run_count
);
1193 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1195 // move to end_state
1196 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1198 jtag_queue_command(cmd
);
1199 cmd
->type
= JTAG_STATEMOVE
;
1200 cmd
->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1201 cmd
->cmd
.statemove
->end_state
= svf_para
.runtest_end_state
;
1203 cmd_queue_end_state
= cmd_queue_cur_state
= cmd
->cmd
.statemove
->end_state
;
1205 last_state
= svf_para
.runtest_end_state
;
1207 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1209 // RUNTEST can only executed in TAP_IDLE
1210 LOG_ERROR("cannot runtest in %s state", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1214 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1220 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1225 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1226 if (num_of_argu
< 2)
1228 LOG_ERROR("invalid parameter of %s", argus
[0]);
1231 if (num_of_argu
> 2)
1233 // STATE pathstate1 ... stable_state
1234 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1237 LOG_ERROR("not enough memory");
1240 num_of_argu
--; // num of path
1241 i_tmp
= 1; // path is from patameter 1
1242 for (i
= 0; i
< num_of_argu
; i
++)
1244 path
[i
] = svf_find_string_in_array(argus
[i_tmp
++], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1245 if (!svf_tap_state_is_valid(path
[i
]))
1247 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[i
]]);
1250 if (TAP_RESET
== path
[i
])
1254 jtag_add_pathmove(i
, path
);
1257 num_of_argu
-= i
+ 1;
1261 if (num_of_argu
> 0)
1263 // execute last path if necessary
1264 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1266 // last state MUST be stable state
1267 // TODO: call path_move
1268 jtag_add_pathmove(num_of_argu
, path
);
1269 last_state
= path
[num_of_argu
- 1];
1270 LOG_DEBUG("\tmove to %s by path_move", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1274 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1278 // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1287 // STATE stable_state
1288 state
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1289 if (svf_tap_state_is_stable(state
))
1291 // TODO: move to state
1292 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1294 jtag_queue_command(cmd
);
1296 cmd
->type
= JTAG_STATEMOVE
;
1297 cmd
->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1298 cmd
->cmd
.statemove
->end_state
= state
;
1300 cmd_queue_end_state
= cmd_queue_cur_state
= cmd
->cmd
.statemove
->end_state
;
1303 LOG_DEBUG("\tmove to %s by state_move", svf_tap_state_name
[state
]);
1307 LOG_ERROR("%s is not valid state", svf_tap_state_name
[state
]);
1314 if (num_of_argu
!= 2)
1316 LOG_ERROR("invalid parameter of %s", argus
[0]);
1319 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1321 if (ERROR_OK
!= svf_execute_tap())
1325 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_trst_mode_name
, dimof(svf_trst_mode_name
));
1329 last_state
= TAP_RESET
;
1330 jtag_add_reset(1, 0);
1334 jtag_add_reset(0, 0);
1339 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1342 svf_para
.trst_mode
= i_tmp
;
1343 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1347 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1352 LOG_ERROR("invalid svf command: %s", argus
[0]);
1357 if (debug_level
>= LOG_LVL_DEBUG
)
1359 // for convenient debugging, execute tap if possible
1360 if ((svf_buffer_index
> 0) && \
1361 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1362 ((command
== STATE
) && (num_of_argu
== 2))))
1364 if (ERROR_OK
!= svf_execute_tap())
1369 // output debug info
1370 if ((SIR
== command
) || (SDR
== command
))
1373 memcpy(&read_value
, svf_tdi_buffer
, sizeof(int));
1374 // in debug mode, data is from index 0
1375 int read_mask
= (1 << (svf_check_tdo_para
[0].bit_len
)) - 1;
1376 LOG_DEBUG("\tTDO read = 0x%X", read_value
& read_mask
);
1382 // for fast executing, execute tap if necessary
1383 // half of the buffer is for the next command
1384 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1385 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1386 ((command
== STATE
) && (num_of_argu
== 2))))
1388 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)