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 unsigned svf_get_mask_u32(int bitlen
)
229 else if (bitlen
>= 32)
231 bitmask
= 0xFFFFFFFF;
235 bitmask
= (1 << bitlen
) - 1;
241 static const char* tap_state_svf_name(tap_state_t state
)
247 case TAP_RESET
: ret
= "RESET"; break;
248 case TAP_IDLE
: ret
= "IDLE"; break;
249 case TAP_DRSELECT
: ret
= "DRSELECT"; break;
250 case TAP_DRCAPTURE
: ret
= "DRCAPTURE"; break;
251 case TAP_DRSHIFT
: ret
= "DRSHIFT"; break;
252 case TAP_DREXIT1
: ret
= "DREXIT1"; break;
253 case TAP_DRPAUSE
: ret
= "DRPAUSE"; break;
254 case TAP_DREXIT2
: ret
= "DREXIT2"; break;
255 case TAP_DRUPDATE
: ret
= "DRUPDATE"; break;
256 case TAP_IRSELECT
: ret
= "IRSELECT"; break;
257 case TAP_IRCAPTURE
: ret
= "IRCAPTURE"; break;
258 case TAP_IRSHIFT
: ret
= "IRSHIFT"; break;
259 case TAP_IREXIT1
: ret
= "IREXIT1"; break;
260 case TAP_IRPAUSE
: ret
= "IRPAUSE"; break;
261 case TAP_IREXIT2
: ret
= "IREXIT2"; break;
262 case TAP_IRUPDATE
: ret
= "IRUPDATE"; break;
263 default: ret
= "???"; break;
269 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
271 #define SVF_NUM_OF_OPTIONS 1
272 int command_num
= 0, i
;
276 if ((argc
< 1) || (argc
> (1 + SVF_NUM_OF_OPTIONS
)))
278 command_print(cmd_ctx
, "usage: svf <file> [quiet]");
284 for (i
= 1; i
< argc
; i
++)
286 if (!strcmp(args
[i
], "quiet"))
292 LOG_ERROR("unknown variant for svf: %s", args
[i
]);
294 // no need to free anything now
299 if ((svf_fd
= open(args
[0], O_RDONLY
)) < 0)
301 command_print(cmd_ctx
, "file \"%s\" not found", args
[0]);
303 // no need to free anything now
307 LOG_USER("svf processing file: \"%s\"", args
[0]);
310 time_ago
= timeval_ms();
314 svf_command_buffer_size
= 0;
316 svf_check_tdo_para_index
= 0;
317 svf_check_tdo_para
= malloc(sizeof(svf_check_tdo_para_t
) * SVF_CHECK_TDO_PARA_SIZE
);
318 if (NULL
== svf_check_tdo_para
)
320 LOG_ERROR("not enough memory");
325 svf_buffer_index
= 0;
326 // double the buffer size
327 // in case current command cannot be commited, and next command is a bit scan command
328 // here is 32K bits for this big scan command, it should be enough
329 // buffer will be reallocated if buffer size is not enough
330 svf_tdi_buffer
= (u8
*)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
331 if (NULL
== svf_tdi_buffer
)
333 LOG_ERROR("not enough memory");
337 svf_tdo_buffer
= (u8
*)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
338 if (NULL
== svf_tdo_buffer
)
340 LOG_ERROR("not enough memory");
344 svf_mask_buffer
= (u8
*)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
345 if (NULL
== svf_mask_buffer
)
347 LOG_ERROR("not enough memory");
351 svf_buffer_size
= 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
;
353 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
354 for (i
= 0; i
< (int)dimof(svf_tap_state_name
); i
++)
356 svf_tap_state_name
[i
] = (char *)tap_state_svf_name(i
);
361 while ( ERROR_OK
== svf_read_command_from_file(svf_fd
) )
363 if (ERROR_OK
!= svf_run_command(cmd_ctx
, svf_command_buffer
))
365 LOG_ERROR("fail to run command at line %d", svf_line_number
);
371 if (ERROR_OK
!= jtag_execute_queue())
375 else if (ERROR_OK
!= svf_check_tdo())
381 command_print(cmd_ctx
, "%lld ms used", timeval_ms() - time_ago
);
389 if (svf_command_buffer
)
391 free(svf_command_buffer
);
392 svf_command_buffer
= NULL
;
393 svf_command_buffer_size
= 0;
395 if (svf_check_tdo_para
)
397 free(svf_check_tdo_para
);
398 svf_check_tdo_para
= NULL
;
399 svf_check_tdo_para_index
= 0;
403 free(svf_tdi_buffer
);
404 svf_tdi_buffer
= NULL
;
408 free(svf_tdo_buffer
);
409 svf_tdo_buffer
= NULL
;
413 free(svf_mask_buffer
);
414 svf_mask_buffer
= NULL
;
416 svf_buffer_index
= 0;
419 svf_free_xxd_para(&svf_para
.hdr_para
);
420 svf_free_xxd_para(&svf_para
.hir_para
);
421 svf_free_xxd_para(&svf_para
.tdr_para
);
422 svf_free_xxd_para(&svf_para
.tir_para
);
423 svf_free_xxd_para(&svf_para
.sdr_para
);
424 svf_free_xxd_para(&svf_para
.sir_para
);
428 command_print(cmd_ctx
, "svf file programmed successfully for %d commands", command_num
);
432 command_print(cmd_ctx
, "svf file programmed failed");
438 #define SVFP_CMD_INC_CNT 1024
439 static int svf_read_command_from_file(int fd
)
441 char ch
, *tmp_buffer
= NULL
;
442 int cmd_pos
= 0, cmd_ok
= 0, slash
= 0, comment
= 0;
444 while (!cmd_ok
&& (read(fd
, &ch
, 1) > 0) )
474 if (cmd_pos
>= svf_command_buffer_size
- 1)
476 tmp_buffer
= (char*)malloc(svf_command_buffer_size
+ SVFP_CMD_INC_CNT
); // 1 more byte for '\0'
477 if (NULL
== tmp_buffer
)
479 LOG_ERROR("not enough memory");
482 if (svf_command_buffer_size
> 0)
484 memcpy(tmp_buffer
, svf_command_buffer
, svf_command_buffer_size
);
486 if (svf_command_buffer
!= NULL
)
488 free(svf_command_buffer
);
490 svf_command_buffer
= tmp_buffer
;
491 svf_command_buffer_size
+= SVFP_CMD_INC_CNT
;
494 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
502 svf_command_buffer
[cmd_pos
] = '\0';
511 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
513 int pos
= 0, num
= 0, space_found
= 1;
523 LOG_ERROR("fail to parse svf command");
533 argus
[num
++] = &str
[pos
];
546 static int svf_tap_state_is_stable(tap_state_t state
)
548 return ((TAP_RESET
== state
) || (TAP_IDLE
== state
) || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
));
551 static int svf_tap_state_is_valid(tap_state_t state
)
553 return state
>= 0 && state
< TAP_NUM_STATES
;
556 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
560 for (i
= 0; i
< num_of_element
; i
++)
562 if (!strcmp(str
, strs
[i
]))
570 static int svf_adjust_array_length(u8
**arr
, int orig_bit_len
, int new_bit_len
)
572 int new_byte_len
= (new_bit_len
+ 7) >> 3;
574 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3)))
581 *arr
= (u8
*)malloc(new_byte_len
);
584 LOG_ERROR("not enough memory");
587 memset(*arr
, 0, new_byte_len
);
592 static int svf_copy_hexstring_to_binary(char *str
, u8
**bin
, int orig_bit_len
, int bit_len
)
594 int i
, str_len
= strlen(str
), str_byte_len
= (bit_len
+ 3) >> 2, loop_cnt
;
595 u8 ch
, need_write
= 1;
597 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
))
599 LOG_ERROR("fail to adjust length of array");
603 if (str_byte_len
> str_len
)
605 loop_cnt
= str_byte_len
;
612 for (i
= 0; i
< loop_cnt
; i
++)
616 ch
= str
[str_len
- i
- 1];
617 if ((ch
>= '0') && (ch
<= '9'))
621 else if ((ch
>= 'A') && (ch
<= 'F'))
627 LOG_ERROR("invalid hex string");
637 if (i
>= str_byte_len
)
639 // all data written, other data should be all '0's and needn't to be written
643 LOG_ERROR("value execede length");
647 else if (i
== (str_byte_len
- 1))
649 // last data byte, written if valid
650 if ((ch
& ~((1 << (bit_len
- 4 * i
)) - 1)) != 0)
652 LOG_ERROR("value execede length");
663 (*bin
)[i
/ 2] |= ch
<< 4;
677 static int svf_check_tdo(void)
681 for (i
= 0; i
< svf_check_tdo_para_index
; i
++)
683 index
= svf_check_tdo_para
[i
].buffer_offset
;
684 len
= svf_check_tdo_para
[i
].bit_len
;
685 if ((svf_check_tdo_para
[i
].enabled
)
686 && buf_cmp_mask(&svf_tdi_buffer
[index
], &svf_tdo_buffer
[index
], &svf_mask_buffer
[index
], len
))
689 unsigned received
, expected
, tapmask
;
690 bitmask
= svf_get_mask_u32(svf_check_tdo_para
[i
].bit_len
);
692 memcpy(&received
, svf_tdi_buffer
+ index
, sizeof(unsigned));
693 memcpy(&expected
, svf_tdo_buffer
+ index
, sizeof(unsigned));
694 memcpy(&tapmask
, svf_mask_buffer
+ index
, sizeof(unsigned));
695 LOG_ERROR("tdo check error at line %d",
696 svf_check_tdo_para
[i
].line_num
);
697 LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
704 svf_check_tdo_para_index
= 0;
709 static int svf_add_check_para(u8 enabled
, int buffer_offset
, int bit_len
)
711 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
713 LOG_ERROR("toooooo many operation undone");
717 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
718 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
719 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
720 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
721 svf_check_tdo_para_index
++;
726 static int svf_execute_tap(void)
728 if (ERROR_OK
!= jtag_execute_queue())
732 else if (ERROR_OK
!= svf_check_tdo())
737 svf_buffer_index
= 0;
742 // not good to use this
743 extern void* cmd_queue_alloc(size_t size
);
744 extern void jtag_queue_command(jtag_command_t
* cmd
);
746 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
)
748 char *argus
[256], command
;
749 int num_of_argu
= 0, i
;
756 float min_time
, max_time
;
758 svf_xxr_para_t
*xxr_para_tmp
;
762 tap_state_t
*path
= NULL
, state
;
766 LOG_USER("%s", svf_command_buffer
);
769 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
774 command
= svf_find_string_in_array(argus
[0], (char **)svf_command_name
, dimof(svf_command_name
));
779 if (num_of_argu
!= 2)
781 LOG_ERROR("invalid parameter of %s", argus
[0]);
784 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
785 if (svf_tap_state_is_stable(i_tmp
))
787 if (command
== ENDIR
)
789 svf_para
.ir_end_state
= i_tmp
;
790 LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name
[svf_para
.ir_end_state
]);
794 svf_para
.dr_end_state
= i_tmp
;
795 LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name
[svf_para
.dr_end_state
]);
800 LOG_ERROR("%s is not valid state", argus
[1]);
805 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
807 LOG_ERROR("invalid parameter of %s", argus
[0]);
810 if (1 == num_of_argu
)
812 // TODO: set jtag speed to full speed
813 svf_para
.frequency
= 0;
817 if (strcmp(argus
[2], "HZ"))
819 LOG_ERROR("HZ not found in FREQUENCY command");
822 if (ERROR_OK
!= svf_execute_tap())
826 svf_para
.frequency
= atof(argus
[1]);
827 // TODO: set jtag speed to
828 if (svf_para
.frequency
> 0)
830 command_run_linef(cmd_ctx
, "jtag_khz %d", (int)svf_para
.frequency
/ 1000);
831 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
836 xxr_para_tmp
= &svf_para
.hdr_para
;
839 xxr_para_tmp
= &svf_para
.hir_para
;
842 xxr_para_tmp
= &svf_para
.tdr_para
;
845 xxr_para_tmp
= &svf_para
.tir_para
;
848 xxr_para_tmp
= &svf_para
.sdr_para
;
851 xxr_para_tmp
= &svf_para
.sir_para
;
854 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
855 if ((num_of_argu
> 10) || (num_of_argu
% 2))
857 LOG_ERROR("invalid parameter of %s", argus
[0]);
860 i_tmp
= xxr_para_tmp
->len
;
861 xxr_para_tmp
->len
= atoi(argus
[1]);
862 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
863 xxr_para_tmp
->data_mask
= 0;
864 for (i
= 2; i
< num_of_argu
; i
+= 2)
866 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
868 LOG_ERROR("data section error");
871 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
872 // TDI, TDO, MASK, SMASK
873 if (!strcmp(argus
[i
], "TDI"))
876 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
877 xxr_para_tmp
->data_mask
|= XXR_TDI
;
879 else if (!strcmp(argus
[i
], "TDO"))
882 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
883 xxr_para_tmp
->data_mask
|= XXR_TDO
;
885 else if (!strcmp(argus
[i
], "MASK"))
888 pbuffer_tmp
= &xxr_para_tmp
->mask
;
889 xxr_para_tmp
->data_mask
|= XXR_MASK
;
891 else if (!strcmp(argus
[i
], "SMASK"))
894 pbuffer_tmp
= &xxr_para_tmp
->smask
;
895 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
899 LOG_ERROR("unknow parameter: %s", argus
[i
]);
902 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
904 LOG_ERROR("fail to parse hex value");
907 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & svf_get_mask_u32(xxr_para_tmp
->len
));
909 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
910 // the mask pattern used is all cares
911 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
913 // MASK not defined and length changed
914 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
916 LOG_ERROR("fail to adjust length of array");
919 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
921 // do scan if necessary
924 // check buffer size first, reallocate if necessary
925 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
926 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
929 // simply print error message
930 LOG_ERROR("buffer is not enough, report to author");
936 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
937 if (NULL
== buffer_tmp
)
939 LOG_ERROR("not enough memory");
942 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
943 // svf_tdi_buffer isn't NULL here
944 free(svf_tdi_buffer
);
945 svf_tdi_buffer
= buffer_tmp
;
947 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
948 if (NULL
== buffer_tmp
)
950 LOG_ERROR("not enough memory");
953 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
954 // svf_tdo_buffer isn't NULL here
955 free(svf_tdo_buffer
);
956 svf_tdo_buffer
= buffer_tmp
;
958 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
959 if (NULL
== buffer_tmp
)
961 LOG_ERROR("not enough memory");
964 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
965 // svf_mask_buffer isn't NULL here
966 free(svf_mask_buffer
);
967 svf_mask_buffer
= buffer_tmp
;
970 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
976 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
977 i
+= svf_para
.hdr_para
.len
;
978 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
979 i
+= svf_para
.sdr_para
.len
;
980 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
981 i
+= svf_para
.tdr_para
.len
;
984 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
986 // assemble dr mask data
988 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
989 i
+= svf_para
.hdr_para
.len
;
990 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
991 i
+= svf_para
.sdr_para
.len
;
992 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
993 i
+= svf_para
.tdr_para
.len
;
994 // assemble dr check data
996 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
997 i
+= svf_para
.hdr_para
.len
;
998 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
999 i
+= svf_para
.sdr_para
.len
;
1000 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1001 i
+= svf_para
.tdr_para
.len
;
1003 svf_add_check_para(1, svf_buffer_index
, i
);
1007 svf_add_check_para(0, svf_buffer_index
, i
);
1011 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1013 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1018 jtag_add_plain_dr_scan(1, &field
, svf_para
.dr_end_state
);
1020 svf_buffer_index
+= (i
+ 7) >> 3;
1021 last_state
= svf_para
.dr_end_state
;
1023 else if (SIR
== command
)
1025 // check buffer size first, reallocate if necessary
1026 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
1027 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1030 // simply print error message
1031 LOG_ERROR("buffer is not enough, report to author");
1036 // reallocate buffer
1037 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1038 if (NULL
== buffer_tmp
)
1040 LOG_ERROR("not enough memory");
1043 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1044 // svf_tdi_buffer isn't NULL here
1045 free(svf_tdi_buffer
);
1046 svf_tdi_buffer
= buffer_tmp
;
1048 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1049 if (NULL
== buffer_tmp
)
1051 LOG_ERROR("not enough memory");
1054 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1055 // svf_tdo_buffer isn't NULL here
1056 free(svf_tdo_buffer
);
1057 svf_tdo_buffer
= buffer_tmp
;
1059 buffer_tmp
= (u8
*)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1060 if (NULL
== buffer_tmp
)
1062 LOG_ERROR("not enough memory");
1065 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1066 // svf_mask_buffer isn't NULL here
1067 free(svf_mask_buffer
);
1068 svf_mask_buffer
= buffer_tmp
;
1071 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1077 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1078 i
+= svf_para
.hir_para
.len
;
1079 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1080 i
+= svf_para
.sir_para
.len
;
1081 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1082 i
+= svf_para
.tir_para
.len
;
1085 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1087 // assemble dr mask data
1089 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1090 i
+= svf_para
.hir_para
.len
;
1091 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1092 i
+= svf_para
.sir_para
.len
;
1093 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1094 i
+= svf_para
.tir_para
.len
;
1095 // assemble dr check data
1097 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1098 i
+= svf_para
.hir_para
.len
;
1099 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1100 i
+= svf_para
.sir_para
.len
;
1101 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1102 i
+= svf_para
.tir_para
.len
;
1104 svf_add_check_para(1, svf_buffer_index
, i
);
1108 svf_add_check_para(0, svf_buffer_index
, i
);
1112 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1114 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1119 jtag_add_plain_ir_scan(1, &field
, svf_para
.ir_end_state
);
1121 svf_buffer_index
+= (i
+ 7) >> 3;
1122 last_state
= svf_para
.ir_end_state
;
1127 LOG_ERROR("PIO and PIOMAP are not supported");
1131 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1132 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1133 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1135 LOG_ERROR("invalid parameter of %s", argus
[0]);
1144 i_tmp
= svf_find_string_in_array(argus
[i
], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1145 if (svf_tap_state_is_valid(i_tmp
))
1147 if (svf_tap_state_is_stable(i_tmp
))
1149 svf_para
.runtest_run_state
= i_tmp
;
1151 // When a run_state is specified, the new run_state becomes the default end_state
1152 svf_para
.runtest_end_state
= i_tmp
;
1153 LOG_DEBUG("\trun_state = %s", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1158 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1162 // run_count run_clk
1163 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1165 if (!strcmp(argus
[i
+ 1], "TCK"))
1167 // clock source is TCK
1168 run_count
= atoi(argus
[i
]);
1169 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1173 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1179 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1181 min_time
= atof(argus
[i
]);
1182 LOG_DEBUG("\tmin_time = %fs", min_time
);
1185 // MAXIMUM max_time SEC
1186 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1188 max_time
= atof(argus
[i
+ 1]);
1189 LOG_DEBUG("\tmax_time = %fs", max_time
);
1192 // ENDSTATE end_state
1193 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1195 i_tmp
= svf_find_string_in_array(argus
[i
+ 1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1196 if (svf_tap_state_is_stable(i_tmp
))
1198 svf_para
.runtest_end_state
= i_tmp
;
1199 LOG_DEBUG("\tend_state = %s", svf_tap_state_name
[svf_para
.runtest_end_state
]);
1203 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1208 // calculate run_count
1209 if ((0 == run_count
) && (min_time
> 0))
1211 run_count
= min_time
* svf_para
.frequency
;
1213 // all parameter should be parsed
1214 if (i
== num_of_argu
)
1218 // run_state and end_state is checked to be stable state
1221 // enter into run_state if necessary
1222 if (last_state
!= svf_para
.runtest_run_state
)
1224 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1226 jtag_queue_command(cmd
);
1228 cmd
->type
= JTAG_STATEMOVE
;
1229 cmd
->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1230 cmd
->cmd
.statemove
->end_state
= svf_para
.runtest_run_state
;
1232 cmd_queue_end_state
= cmd_queue_cur_state
= cmd
->cmd
.statemove
->end_state
;
1235 // call jtag_add_clocks
1236 jtag_add_clocks(run_count
);
1238 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1240 // move to end_state
1241 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1243 jtag_queue_command(cmd
);
1244 cmd
->type
= JTAG_STATEMOVE
;
1245 cmd
->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1246 cmd
->cmd
.statemove
->end_state
= svf_para
.runtest_end_state
;
1248 cmd_queue_end_state
= cmd_queue_cur_state
= cmd
->cmd
.statemove
->end_state
;
1250 last_state
= svf_para
.runtest_end_state
;
1252 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1254 // RUNTEST can only executed in TAP_IDLE
1255 LOG_ERROR("cannot runtest in %s state", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1259 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1265 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1270 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1271 if (num_of_argu
< 2)
1273 LOG_ERROR("invalid parameter of %s", argus
[0]);
1276 if (num_of_argu
> 2)
1278 // STATE pathstate1 ... stable_state
1279 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1282 LOG_ERROR("not enough memory");
1285 num_of_argu
--; // num of path
1286 i_tmp
= 1; // path is from patameter 1
1287 for (i
= 0; i
< num_of_argu
; i
++)
1289 path
[i
] = svf_find_string_in_array(argus
[i_tmp
++], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1290 if (!svf_tap_state_is_valid(path
[i
]))
1292 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[i
]]);
1295 if (TAP_RESET
== path
[i
])
1299 jtag_add_pathmove(i
, path
);
1302 num_of_argu
-= i
+ 1;
1306 if (num_of_argu
> 0)
1308 // execute last path if necessary
1309 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1311 // last state MUST be stable state
1312 // TODO: call path_move
1313 jtag_add_pathmove(num_of_argu
, path
);
1314 last_state
= path
[num_of_argu
- 1];
1315 LOG_DEBUG("\tmove to %s by path_move", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1319 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1323 // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1332 // STATE stable_state
1333 state
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1334 if (svf_tap_state_is_stable(state
))
1336 // TODO: move to state
1337 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1339 jtag_queue_command(cmd
);
1341 cmd
->type
= JTAG_STATEMOVE
;
1342 cmd
->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1343 cmd
->cmd
.statemove
->end_state
= state
;
1345 cmd_queue_end_state
= cmd_queue_cur_state
= cmd
->cmd
.statemove
->end_state
;
1348 LOG_DEBUG("\tmove to %s by state_move", svf_tap_state_name
[state
]);
1352 LOG_ERROR("%s is not valid state", svf_tap_state_name
[state
]);
1359 if (num_of_argu
!= 2)
1361 LOG_ERROR("invalid parameter of %s", argus
[0]);
1364 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1366 if (ERROR_OK
!= svf_execute_tap())
1370 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_trst_mode_name
, dimof(svf_trst_mode_name
));
1374 last_state
= TAP_RESET
;
1375 jtag_add_reset(1, 0);
1379 jtag_add_reset(0, 0);
1384 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1387 svf_para
.trst_mode
= i_tmp
;
1388 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1392 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1397 LOG_ERROR("invalid svf command: %s", argus
[0]);
1402 if (debug_level
>= LOG_LVL_DEBUG
)
1404 // for convenient debugging, execute tap if possible
1405 if ((svf_buffer_index
> 0) && \
1406 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1407 ((command
== STATE
) && (num_of_argu
== 2))))
1409 if (ERROR_OK
!= svf_execute_tap())
1414 // output debug info
1415 if ((SIR
== command
) || (SDR
== command
))
1418 memcpy(&read_value
, svf_tdi_buffer
, sizeof(int));
1419 // in debug mode, data is from index 0
1420 int read_mask
= svf_get_mask_u32(svf_check_tdo_para
[0].bit_len
);
1421 LOG_DEBUG("\tTDO read = 0x%X", read_value
& read_mask
);
1427 // for fast executing, execute tap if necessary
1428 // half of the buffer is for the next command
1429 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1430 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1431 ((command
== STATE
) && (num_of_argu
== 2))))
1433 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)