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] =
97 uint32_t num_of_moves
;
101 svf_statemove_t svf_statemoves
[] =
103 // from to num_of_moves, paths[8]
104 // {TAP_RESET, TAP_RESET, 1, {TAP_RESET}},
105 {TAP_RESET
, TAP_IDLE
, 2, {TAP_RESET
, TAP_IDLE
}},
106 {TAP_RESET
, TAP_DRPAUSE
, 6, {TAP_RESET
, TAP_IDLE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DREXIT1
, TAP_DRPAUSE
}},
107 {TAP_RESET
, TAP_IRPAUSE
, 7, {TAP_RESET
, TAP_IDLE
, TAP_DRSELECT
, TAP_IRSELECT
, TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
}},
109 // {TAP_IDLE, TAP_RESET, 4, {TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
110 {TAP_IDLE
, TAP_IDLE
, 1, {TAP_IDLE
}},
111 {TAP_IDLE
, TAP_DRPAUSE
, 5, {TAP_IDLE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DREXIT1
, TAP_DRPAUSE
}},
112 {TAP_IDLE
, TAP_IRPAUSE
, 6, {TAP_IDLE
, TAP_DRSELECT
, TAP_IRSELECT
, TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
}},
114 // {TAP_DRPAUSE, TAP_RESET, 6, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
115 {TAP_DRPAUSE
, TAP_IDLE
, 4, {TAP_DRPAUSE
, TAP_DREXIT2
, TAP_DRUPDATE
, TAP_IDLE
}},
116 {TAP_DRPAUSE
, TAP_DRPAUSE
, 7, {TAP_DRPAUSE
, TAP_DREXIT2
, TAP_DRUPDATE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DREXIT1
, TAP_DRPAUSE
}},
117 {TAP_DRPAUSE
, TAP_IRPAUSE
, 8, {TAP_DRPAUSE
, TAP_DREXIT2
, TAP_DRUPDATE
, TAP_DRSELECT
, TAP_IRSELECT
, TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
}},
119 // {TAP_IRPAUSE, TAP_RESET, 6, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
120 {TAP_IRPAUSE
, TAP_IDLE
, 4, {TAP_IRPAUSE
, TAP_IREXIT2
, TAP_IRUPDATE
, TAP_IDLE
}},
121 {TAP_IRPAUSE
, TAP_DRPAUSE
, 7, {TAP_IRPAUSE
, TAP_IREXIT2
, TAP_IRUPDATE
, TAP_DRSELECT
, TAP_DRCAPTURE
, TAP_DREXIT1
, TAP_DRPAUSE
}},
122 {TAP_IRPAUSE
, TAP_IRPAUSE
, 8, {TAP_IRPAUSE
, TAP_IREXIT2
, TAP_IRUPDATE
, TAP_DRSELECT
, TAP_IRSELECT
, TAP_IRCAPTURE
, TAP_IREXIT1
, TAP_IRPAUSE
}}
125 char *svf_tap_state_name
[TAP_NUM_STATES
];
127 #define XXR_TDI (1 << 0)
128 #define XXR_TDO (1 << 1)
129 #define XXR_MASK (1 << 2)
130 #define XXR_SMASK (1 << 3)
144 tap_state_t ir_end_state
;
145 tap_state_t dr_end_state
;
146 tap_state_t runtest_run_state
;
147 tap_state_t runtest_end_state
;
148 trst_mode_t trst_mode
;
150 svf_xxr_para_t hir_para
;
151 svf_xxr_para_t hdr_para
;
152 svf_xxr_para_t tir_para
;
153 svf_xxr_para_t tdr_para
;
154 svf_xxr_para_t sir_para
;
155 svf_xxr_para_t sdr_para
;
159 const svf_para_t svf_para_init
=
161 // frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode
162 0, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TAP_IDLE
, TRST_Z
,
164 // {len, data_mask, tdi, tdo, mask, smask},
165 {0, 0, NULL
, NULL
, NULL
, NULL
},
167 // {len, data_mask, tdi, tdo, mask, smask},
168 {0, 0, NULL
, NULL
, NULL
, NULL
},
170 // {len, data_mask, tdi, tdo, mask, smask},
171 {0, 0, NULL
, NULL
, NULL
, NULL
},
173 // {len, data_mask, tdi, tdo, mask, smask},
174 {0, 0, NULL
, NULL
, NULL
, NULL
},
176 // {len, data_mask, tdi, tdo, mask, smask},
177 {0, 0, NULL
, NULL
, NULL
, NULL
},
179 // {len, data_mask, tdi, tdo, mask, smask},
180 {0, 0, NULL
, NULL
, NULL
, NULL
},
185 int line_num
; // used to record line number of the check operation
186 // so more information could be printed
187 int enabled
; // check is enabled or not
188 int buffer_offset
; // buffer_offset to buffers
189 int bit_len
; // bit length to check
190 }svf_check_tdo_para_t
;
192 #define SVF_CHECK_TDO_PARA_SIZE 1024
193 static svf_check_tdo_para_t
*svf_check_tdo_para
= NULL
;
194 static int svf_check_tdo_para_index
= 0;
196 #define dimof(a) (sizeof(a) / sizeof((a)[0]))
198 static int svf_read_command_from_file(int fd
);
199 static int svf_check_tdo(void);
200 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
);
201 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
);
202 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
204 static int svf_fd
= 0;
205 static char *svf_command_buffer
= NULL
;
206 static int svf_command_buffer_size
= 0;
207 static int svf_line_number
= 1;
209 static jtag_tap_t
*tap
= NULL
;
211 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (4 * 1024)
212 static uint8_t *svf_tdi_buffer
= NULL
, *svf_tdo_buffer
= NULL
, *svf_mask_buffer
= NULL
;
213 static int svf_buffer_index
= 0, svf_buffer_size
= 0;
214 static int svf_quiet
= 0;
217 int svf_register_commands(struct command_context_s
*cmd_ctx
)
219 register_command(cmd_ctx
, NULL
, "svf", handle_svf_command
,
220 COMMAND_EXEC
, "run svf <file>");
225 void svf_free_xxd_para(svf_xxr_para_t
*para
)
229 if (para
->tdi
!= NULL
)
234 if (para
->tdo
!= NULL
)
239 if (para
->mask
!= NULL
)
244 if (para
->smask
!= NULL
)
252 unsigned svf_get_mask_u32(int bitlen
)
260 else if (bitlen
>= 32)
262 bitmask
= 0xFFFFFFFF;
266 bitmask
= (1 << bitlen
) - 1;
272 static const char* tap_state_svf_name(tap_state_t state
)
278 case TAP_RESET
: ret
= "RESET"; break;
279 case TAP_IDLE
: ret
= "IDLE"; break;
280 case TAP_DRSELECT
: ret
= "DRSELECT"; break;
281 case TAP_DRCAPTURE
: ret
= "DRCAPTURE"; break;
282 case TAP_DRSHIFT
: ret
= "DRSHIFT"; break;
283 case TAP_DREXIT1
: ret
= "DREXIT1"; break;
284 case TAP_DRPAUSE
: ret
= "DRPAUSE"; break;
285 case TAP_DREXIT2
: ret
= "DREXIT2"; break;
286 case TAP_DRUPDATE
: ret
= "DRUPDATE"; break;
287 case TAP_IRSELECT
: ret
= "IRSELECT"; break;
288 case TAP_IRCAPTURE
: ret
= "IRCAPTURE"; break;
289 case TAP_IRSHIFT
: ret
= "IRSHIFT"; break;
290 case TAP_IREXIT1
: ret
= "IREXIT1"; break;
291 case TAP_IRPAUSE
: ret
= "IRPAUSE"; break;
292 case TAP_IREXIT2
: ret
= "IREXIT2"; break;
293 case TAP_IRUPDATE
: ret
= "IRUPDATE"; break;
294 default: ret
= "???"; break;
300 static int svf_add_statemove(tap_state_t state_to
)
302 tap_state_t state_from
= cmd_queue_cur_state
;
305 for (index
= 0; index
< dimof(svf_statemoves
); index
++)
307 if ((svf_statemoves
[index
].from
== state_from
)
308 && (svf_statemoves
[index
].to
== state_to
))
310 if (TAP_RESET
== state_from
)
313 if (svf_statemoves
[index
].num_of_moves
> 1)
315 jtag_add_pathmove(svf_statemoves
[index
].num_of_moves
- 1, svf_statemoves
[index
].paths
+ 1);
320 if (svf_statemoves
[index
].num_of_moves
> 0)
322 jtag_add_pathmove(svf_statemoves
[index
].num_of_moves
, svf_statemoves
[index
].paths
);
328 LOG_ERROR("can not move to %s", tap_state_svf_name(state_to
));
332 static int handle_svf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
334 #define SVF_NUM_OF_OPTIONS 1
335 int command_num
= 0, i
;
339 if ((argc
< 1) || (argc
> (1 + SVF_NUM_OF_OPTIONS
)))
341 command_print(cmd_ctx
, "usage: svf <file> [quiet]");
347 for (i
= 1; i
< argc
; i
++)
349 if (!strcmp(args
[i
], "quiet"))
355 LOG_ERROR("unknown variant for svf: %s", args
[i
]);
357 // no need to free anything now
362 if ((svf_fd
= open(args
[0], O_RDONLY
)) < 0)
364 command_print(cmd_ctx
, "file \"%s\" not found", args
[0]);
366 // no need to free anything now
370 LOG_USER("svf processing file: \"%s\"", args
[0]);
373 time_ago
= timeval_ms();
377 svf_command_buffer_size
= 0;
379 svf_check_tdo_para_index
= 0;
380 svf_check_tdo_para
= malloc(sizeof(svf_check_tdo_para_t
) * SVF_CHECK_TDO_PARA_SIZE
);
381 if (NULL
== svf_check_tdo_para
)
383 LOG_ERROR("not enough memory");
388 svf_buffer_index
= 0;
389 // double the buffer size
390 // in case current command cannot be commited, and next command is a bit scan command
391 // here is 32K bits for this big scan command, it should be enough
392 // buffer will be reallocated if buffer size is not enough
393 svf_tdi_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
394 if (NULL
== svf_tdi_buffer
)
396 LOG_ERROR("not enough memory");
400 svf_tdo_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
401 if (NULL
== svf_tdo_buffer
)
403 LOG_ERROR("not enough memory");
407 svf_mask_buffer
= (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
);
408 if (NULL
== svf_mask_buffer
)
410 LOG_ERROR("not enough memory");
414 svf_buffer_size
= 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT
;
416 memcpy(&svf_para
, &svf_para_init
, sizeof(svf_para
));
417 for (i
= 0; i
< (int)dimof(svf_tap_state_name
); i
++)
419 svf_tap_state_name
[i
] = (char *)tap_state_svf_name(i
);
425 while (ERROR_OK
== svf_read_command_from_file(svf_fd
))
427 if (ERROR_OK
!= svf_run_command(cmd_ctx
, svf_command_buffer
))
429 LOG_ERROR("fail to run command at line %d", svf_line_number
);
435 if (ERROR_OK
!= jtag_execute_queue())
439 else if (ERROR_OK
!= svf_check_tdo())
445 command_print(cmd_ctx
, "%lld ms used", timeval_ms() - time_ago
);
453 if (svf_command_buffer
)
455 free(svf_command_buffer
);
456 svf_command_buffer
= NULL
;
457 svf_command_buffer_size
= 0;
459 if (svf_check_tdo_para
)
461 free(svf_check_tdo_para
);
462 svf_check_tdo_para
= NULL
;
463 svf_check_tdo_para_index
= 0;
467 free(svf_tdi_buffer
);
468 svf_tdi_buffer
= NULL
;
472 free(svf_tdo_buffer
);
473 svf_tdo_buffer
= NULL
;
477 free(svf_mask_buffer
);
478 svf_mask_buffer
= NULL
;
480 svf_buffer_index
= 0;
483 svf_free_xxd_para(&svf_para
.hdr_para
);
484 svf_free_xxd_para(&svf_para
.hir_para
);
485 svf_free_xxd_para(&svf_para
.tdr_para
);
486 svf_free_xxd_para(&svf_para
.tir_para
);
487 svf_free_xxd_para(&svf_para
.sdr_para
);
488 svf_free_xxd_para(&svf_para
.sir_para
);
492 command_print(cmd_ctx
, "svf file programmed successfully for %d commands", command_num
);
496 command_print(cmd_ctx
, "svf file programmed failed");
502 #define SVFP_CMD_INC_CNT 1024
503 static int svf_read_command_from_file(int fd
)
505 char ch
, *tmp_buffer
= NULL
;
506 int cmd_pos
= 0, cmd_ok
= 0, slash
= 0, comment
= 0;
508 while (!cmd_ok
&& (read(fd
, &ch
, 1) > 0))
538 if (cmd_pos
>= svf_command_buffer_size
- 1)
540 tmp_buffer
= (char*)malloc(svf_command_buffer_size
+ SVFP_CMD_INC_CNT
); // 1 more byte for '\0'
541 if (NULL
== tmp_buffer
)
543 LOG_ERROR("not enough memory");
546 if (svf_command_buffer_size
> 0)
548 memcpy(tmp_buffer
, svf_command_buffer
, svf_command_buffer_size
);
550 if (svf_command_buffer
!= NULL
)
552 free(svf_command_buffer
);
554 svf_command_buffer
= tmp_buffer
;
555 svf_command_buffer_size
+= SVFP_CMD_INC_CNT
;
558 svf_command_buffer
[cmd_pos
++] = (char)toupper(ch
);
566 svf_command_buffer
[cmd_pos
] = '\0';
575 static int svf_parse_cmd_string(char *str
, int len
, char **argus
, int *num_of_argu
)
577 int pos
= 0, num
= 0, space_found
= 1;
587 LOG_ERROR("fail to parse svf command");
597 argus
[num
++] = &str
[pos
];
610 static int svf_tap_state_is_stable(tap_state_t state
)
612 return ((TAP_RESET
== state
) || (TAP_IDLE
== state
) || (TAP_DRPAUSE
== state
) || (TAP_IRPAUSE
== state
));
615 static int svf_tap_state_is_valid(tap_state_t state
)
617 return state
>= 0 && state
< TAP_NUM_STATES
;
620 static int svf_find_string_in_array(char *str
, char **strs
, int num_of_element
)
624 for (i
= 0; i
< num_of_element
; i
++)
626 if (!strcmp(str
, strs
[i
]))
634 static int svf_adjust_array_length(uint8_t **arr
, int orig_bit_len
, int new_bit_len
)
636 int new_byte_len
= (new_bit_len
+ 7) >> 3;
638 if ((NULL
== *arr
) || (((orig_bit_len
+ 7) >> 3) < ((new_bit_len
+ 7) >> 3)))
645 *arr
= (uint8_t*)malloc(new_byte_len
);
648 LOG_ERROR("not enough memory");
651 memset(*arr
, 0, new_byte_len
);
656 static int svf_copy_hexstring_to_binary(char *str
, uint8_t **bin
, int orig_bit_len
, int bit_len
)
658 int i
, str_len
= strlen(str
), str_hbyte_len
= (bit_len
+ 3) >> 2;
661 if (ERROR_OK
!= svf_adjust_array_length(bin
, orig_bit_len
, bit_len
))
663 LOG_ERROR("fail to adjust length of array");
667 for (i
= 0; i
< str_hbyte_len
; i
++)
676 if ((ch
>= '0') && (ch
<= '9'))
681 else if ((ch
>= 'A') && (ch
<= 'F'))
688 LOG_ERROR("invalid hex string");
700 (*bin
)[i
/ 2] |= ch
<< 4;
711 if (str_len
> 0 || (ch
& ~((1 << (4 - (bit_len
% 4))) - 1)) != 0)
713 LOG_ERROR("value execede length");
720 static int svf_check_tdo(void)
724 for (i
= 0; i
< svf_check_tdo_para_index
; i
++)
726 index
= svf_check_tdo_para
[i
].buffer_offset
;
727 len
= svf_check_tdo_para
[i
].bit_len
;
728 if ((svf_check_tdo_para
[i
].enabled
)
729 && buf_cmp_mask(&svf_tdi_buffer
[index
], &svf_tdo_buffer
[index
], &svf_mask_buffer
[index
], len
))
732 unsigned received
, expected
, tapmask
;
733 bitmask
= svf_get_mask_u32(svf_check_tdo_para
[i
].bit_len
);
735 memcpy(&received
, svf_tdi_buffer
+ index
, sizeof(unsigned));
736 memcpy(&expected
, svf_tdo_buffer
+ index
, sizeof(unsigned));
737 memcpy(&tapmask
, svf_mask_buffer
+ index
, sizeof(unsigned));
738 LOG_ERROR("tdo check error at line %d",
739 svf_check_tdo_para
[i
].line_num
);
740 LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
747 svf_check_tdo_para_index
= 0;
752 static int svf_add_check_para(uint8_t enabled
, int buffer_offset
, int bit_len
)
754 if (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
)
756 LOG_ERROR("toooooo many operation undone");
760 svf_check_tdo_para
[svf_check_tdo_para_index
].line_num
= svf_line_number
;
761 svf_check_tdo_para
[svf_check_tdo_para_index
].bit_len
= bit_len
;
762 svf_check_tdo_para
[svf_check_tdo_para_index
].enabled
= enabled
;
763 svf_check_tdo_para
[svf_check_tdo_para_index
].buffer_offset
= buffer_offset
;
764 svf_check_tdo_para_index
++;
769 static int svf_execute_tap(void)
771 if (ERROR_OK
!= jtag_execute_queue())
775 else if (ERROR_OK
!= svf_check_tdo())
780 svf_buffer_index
= 0;
785 static int svf_run_command(struct command_context_s
*cmd_ctx
, char *cmd_str
)
787 char *argus
[256], command
;
788 int num_of_argu
= 0, i
;
795 float min_time
, max_time
;
797 svf_xxr_para_t
*xxr_para_tmp
;
798 uint8_t **pbuffer_tmp
;
801 tap_state_t
*path
= NULL
, state
;
805 LOG_USER("%s", svf_command_buffer
);
808 if (ERROR_OK
!= svf_parse_cmd_string(cmd_str
, strlen(cmd_str
), argus
, &num_of_argu
))
813 command
= svf_find_string_in_array(argus
[0], (char **)svf_command_name
, dimof(svf_command_name
));
818 if (num_of_argu
!= 2)
820 LOG_ERROR("invalid parameter of %s", argus
[0]);
823 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
824 if (svf_tap_state_is_stable(i_tmp
))
826 if (command
== ENDIR
)
828 svf_para
.ir_end_state
= i_tmp
;
829 LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name
[svf_para
.ir_end_state
]);
833 svf_para
.dr_end_state
= i_tmp
;
834 LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name
[svf_para
.dr_end_state
]);
839 LOG_ERROR("%s is not valid state", argus
[1]);
844 if ((num_of_argu
!= 1) && (num_of_argu
!= 3))
846 LOG_ERROR("invalid parameter of %s", argus
[0]);
849 if (1 == num_of_argu
)
851 // TODO: set jtag speed to full speed
852 svf_para
.frequency
= 0;
856 if (strcmp(argus
[2], "HZ"))
858 LOG_ERROR("HZ not found in FREQUENCY command");
861 if (ERROR_OK
!= svf_execute_tap())
865 svf_para
.frequency
= atof(argus
[1]);
866 // TODO: set jtag speed to
867 if (svf_para
.frequency
> 0)
869 command_run_linef(cmd_ctx
, "jtag_khz %d", (int)svf_para
.frequency
/ 1000);
870 LOG_DEBUG("\tfrequency = %f", svf_para
.frequency
);
875 xxr_para_tmp
= &svf_para
.hdr_para
;
878 xxr_para_tmp
= &svf_para
.hir_para
;
881 xxr_para_tmp
= &svf_para
.tdr_para
;
884 xxr_para_tmp
= &svf_para
.tir_para
;
887 xxr_para_tmp
= &svf_para
.sdr_para
;
890 xxr_para_tmp
= &svf_para
.sir_para
;
893 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
894 if ((num_of_argu
> 10) || (num_of_argu
% 2))
896 LOG_ERROR("invalid parameter of %s", argus
[0]);
899 i_tmp
= xxr_para_tmp
->len
;
900 xxr_para_tmp
->len
= atoi(argus
[1]);
901 LOG_DEBUG("\tlength = %d", xxr_para_tmp
->len
);
902 xxr_para_tmp
->data_mask
= 0;
903 for (i
= 2; i
< num_of_argu
; i
+= 2)
905 if ((strlen(argus
[i
+ 1]) < 3) || (argus
[i
+ 1][0] != '(') || (argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] != ')'))
907 LOG_ERROR("data section error");
910 argus
[i
+ 1][strlen(argus
[i
+ 1]) - 1] = '\0';
911 // TDI, TDO, MASK, SMASK
912 if (!strcmp(argus
[i
], "TDI"))
915 pbuffer_tmp
= &xxr_para_tmp
->tdi
;
916 xxr_para_tmp
->data_mask
|= XXR_TDI
;
918 else if (!strcmp(argus
[i
], "TDO"))
921 pbuffer_tmp
= &xxr_para_tmp
->tdo
;
922 xxr_para_tmp
->data_mask
|= XXR_TDO
;
924 else if (!strcmp(argus
[i
], "MASK"))
927 pbuffer_tmp
= &xxr_para_tmp
->mask
;
928 xxr_para_tmp
->data_mask
|= XXR_MASK
;
930 else if (!strcmp(argus
[i
], "SMASK"))
933 pbuffer_tmp
= &xxr_para_tmp
->smask
;
934 xxr_para_tmp
->data_mask
|= XXR_SMASK
;
938 LOG_ERROR("unknow parameter: %s", argus
[i
]);
941 if (ERROR_OK
!= svf_copy_hexstring_to_binary(&argus
[i
+ 1][1], pbuffer_tmp
, i_tmp
, xxr_para_tmp
->len
))
943 LOG_ERROR("fail to parse hex value");
946 LOG_DEBUG("\t%s = 0x%X", argus
[i
], (**(int**)pbuffer_tmp
) & svf_get_mask_u32(xxr_para_tmp
->len
));
948 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
949 // the mask pattern used is all cares
950 if (!(xxr_para_tmp
->data_mask
& XXR_MASK
) && (i_tmp
!= xxr_para_tmp
->len
))
952 // MASK not defined and length changed
953 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
955 LOG_ERROR("fail to adjust length of array");
958 buf_set_ones(xxr_para_tmp
->mask
, xxr_para_tmp
->len
);
960 // If TDO is absent, no comparison is needed, set the mask to 0
961 if (!(xxr_para_tmp
->data_mask
& XXR_TDO
))
963 if (NULL
== xxr_para_tmp
->tdo
)
965 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->tdo
, i_tmp
, xxr_para_tmp
->len
))
967 LOG_ERROR("fail to adjust length of array");
971 if (NULL
== xxr_para_tmp
->mask
)
973 if (ERROR_OK
!= svf_adjust_array_length(&xxr_para_tmp
->mask
, i_tmp
, xxr_para_tmp
->len
))
975 LOG_ERROR("fail to adjust length of array");
979 memset(xxr_para_tmp
->mask
, 0, (xxr_para_tmp
->len
+ 7) >> 3);
981 // do scan if necessary
984 // check buffer size first, reallocate if necessary
985 i
= svf_para
.hdr_para
.len
+ svf_para
.sdr_para
.len
+ svf_para
.tdr_para
.len
;
986 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
989 // simply print error message
990 LOG_ERROR("buffer is not enough, report to author");
996 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
997 if (NULL
== buffer_tmp
)
999 LOG_ERROR("not enough memory");
1002 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1003 // svf_tdi_buffer isn't NULL here
1004 free(svf_tdi_buffer
);
1005 svf_tdi_buffer
= buffer_tmp
;
1007 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1008 if (NULL
== buffer_tmp
)
1010 LOG_ERROR("not enough memory");
1013 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1014 // svf_tdo_buffer isn't NULL here
1015 free(svf_tdo_buffer
);
1016 svf_tdo_buffer
= buffer_tmp
;
1018 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1019 if (NULL
== buffer_tmp
)
1021 LOG_ERROR("not enough memory");
1024 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1025 // svf_mask_buffer isn't NULL here
1026 free(svf_mask_buffer
);
1027 svf_mask_buffer
= buffer_tmp
;
1030 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1036 buf_set_buf(svf_para
.hdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1037 i
+= svf_para
.hdr_para
.len
;
1038 buf_set_buf(svf_para
.sdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1039 i
+= svf_para
.sdr_para
.len
;
1040 buf_set_buf(svf_para
.tdr_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1041 i
+= svf_para
.tdr_para
.len
;
1044 if (svf_para
.sdr_para
.data_mask
& XXR_TDO
)
1046 // assemble dr mask data
1048 buf_set_buf(svf_para
.hdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1049 i
+= svf_para
.hdr_para
.len
;
1050 buf_set_buf(svf_para
.sdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1051 i
+= svf_para
.sdr_para
.len
;
1052 buf_set_buf(svf_para
.tdr_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1053 i
+= svf_para
.tdr_para
.len
;
1054 // assemble dr check data
1056 buf_set_buf(svf_para
.hdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hdr_para
.len
);
1057 i
+= svf_para
.hdr_para
.len
;
1058 buf_set_buf(svf_para
.sdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sdr_para
.len
);
1059 i
+= svf_para
.sdr_para
.len
;
1060 buf_set_buf(svf_para
.tdr_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tdr_para
.len
);
1061 i
+= svf_para
.tdr_para
.len
;
1063 svf_add_check_para(1, svf_buffer_index
, i
);
1067 svf_add_check_para(0, svf_buffer_index
, i
);
1071 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1072 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1073 jtag_add_plain_dr_scan(1, &field
, svf_para
.dr_end_state
);
1075 svf_buffer_index
+= (i
+ 7) >> 3;
1077 else if (SIR
== command
)
1079 // check buffer size first, reallocate if necessary
1080 i
= svf_para
.hir_para
.len
+ svf_para
.sir_para
.len
+ svf_para
.tir_para
.len
;
1081 if ((svf_buffer_size
- svf_buffer_index
) < ((i
+ 7) >> 3))
1084 // simply print error message
1085 LOG_ERROR("buffer is not enough, report to author");
1088 uint8_t *buffer_tmp
;
1090 // reallocate buffer
1091 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1092 if (NULL
== buffer_tmp
)
1094 LOG_ERROR("not enough memory");
1097 memcpy(buffer_tmp
, svf_tdi_buffer
, svf_buffer_index
);
1098 // svf_tdi_buffer isn't NULL here
1099 free(svf_tdi_buffer
);
1100 svf_tdi_buffer
= buffer_tmp
;
1102 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1103 if (NULL
== buffer_tmp
)
1105 LOG_ERROR("not enough memory");
1108 memcpy(buffer_tmp
, svf_tdo_buffer
, svf_buffer_index
);
1109 // svf_tdo_buffer isn't NULL here
1110 free(svf_tdo_buffer
);
1111 svf_tdo_buffer
= buffer_tmp
;
1113 buffer_tmp
= (uint8_t *)malloc(svf_buffer_index
+ ((i
+ 7) >> 3));
1114 if (NULL
== buffer_tmp
)
1116 LOG_ERROR("not enough memory");
1119 memcpy(buffer_tmp
, svf_mask_buffer
, svf_buffer_index
);
1120 // svf_mask_buffer isn't NULL here
1121 free(svf_mask_buffer
);
1122 svf_mask_buffer
= buffer_tmp
;
1125 svf_buffer_size
= svf_buffer_index
+ ((i
+ 7) >> 3);
1131 buf_set_buf(svf_para
.hir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1132 i
+= svf_para
.hir_para
.len
;
1133 buf_set_buf(svf_para
.sir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1134 i
+= svf_para
.sir_para
.len
;
1135 buf_set_buf(svf_para
.tir_para
.tdi
, 0, &svf_tdi_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1136 i
+= svf_para
.tir_para
.len
;
1139 if (svf_para
.sir_para
.data_mask
& XXR_TDO
)
1141 // assemble dr mask data
1143 buf_set_buf(svf_para
.hir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1144 i
+= svf_para
.hir_para
.len
;
1145 buf_set_buf(svf_para
.sir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1146 i
+= svf_para
.sir_para
.len
;
1147 buf_set_buf(svf_para
.tir_para
.mask
, 0, &svf_mask_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1148 i
+= svf_para
.tir_para
.len
;
1149 // assemble dr check data
1151 buf_set_buf(svf_para
.hir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.hir_para
.len
);
1152 i
+= svf_para
.hir_para
.len
;
1153 buf_set_buf(svf_para
.sir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.sir_para
.len
);
1154 i
+= svf_para
.sir_para
.len
;
1155 buf_set_buf(svf_para
.tir_para
.tdo
, 0, &svf_tdo_buffer
[svf_buffer_index
], i
, svf_para
.tir_para
.len
);
1156 i
+= svf_para
.tir_para
.len
;
1158 svf_add_check_para(1, svf_buffer_index
, i
);
1162 svf_add_check_para(0, svf_buffer_index
, i
);
1166 field
.out_value
= &svf_tdi_buffer
[svf_buffer_index
];
1167 field
.in_value
= &svf_tdi_buffer
[svf_buffer_index
];
1168 jtag_add_plain_ir_scan(1, &field
, svf_para
.ir_end_state
);
1170 svf_buffer_index
+= (i
+ 7) >> 3;
1175 LOG_ERROR("PIO and PIOMAP are not supported");
1179 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1180 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1181 if ((num_of_argu
< 3) && (num_of_argu
> 11))
1183 LOG_ERROR("invalid parameter of %s", argus
[0]);
1192 i_tmp
= svf_find_string_in_array(argus
[i
], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1193 if (svf_tap_state_is_valid(i_tmp
))
1195 if (svf_tap_state_is_stable(i_tmp
))
1197 svf_para
.runtest_run_state
= i_tmp
;
1199 // When a run_state is specified, the new run_state becomes the default end_state
1200 svf_para
.runtest_end_state
= i_tmp
;
1201 LOG_DEBUG("\trun_state = %s", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1206 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1210 // run_count run_clk
1211 if (((i
+ 2) <= num_of_argu
) && strcmp(argus
[i
+ 1], "SEC"))
1213 if (!strcmp(argus
[i
+ 1], "TCK"))
1215 // clock source is TCK
1216 run_count
= atoi(argus
[i
]);
1217 LOG_DEBUG("\trun_count@TCK = %d", run_count
);
1221 LOG_ERROR("%s not supported for clock", argus
[i
+ 1]);
1227 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
+ 1], "SEC"))
1229 min_time
= atof(argus
[i
]);
1230 LOG_DEBUG("\tmin_time = %fs", min_time
);
1233 // MAXIMUM max_time SEC
1234 if (((i
+ 3) <= num_of_argu
) && !strcmp(argus
[i
], "MAXIMUM") && !strcmp(argus
[i
+ 2], "SEC"))
1236 max_time
= atof(argus
[i
+ 1]);
1237 LOG_DEBUG("\tmax_time = %fs", max_time
);
1240 // ENDSTATE end_state
1241 if (((i
+ 2) <= num_of_argu
) && !strcmp(argus
[i
], "ENDSTATE"))
1243 i_tmp
= svf_find_string_in_array(argus
[i
+ 1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1244 if (svf_tap_state_is_stable(i_tmp
))
1246 svf_para
.runtest_end_state
= i_tmp
;
1247 LOG_DEBUG("\tend_state = %s", svf_tap_state_name
[svf_para
.runtest_end_state
]);
1251 LOG_ERROR("%s is not valid state", svf_tap_state_name
[i_tmp
]);
1256 // calculate run_count
1257 if ((0 == run_count
) && (min_time
> 0))
1259 run_count
= min_time
* svf_para
.frequency
;
1261 // all parameter should be parsed
1262 if (i
== num_of_argu
)
1266 // run_state and end_state is checked to be stable state
1269 // enter into run_state if necessary
1270 if (cmd_queue_cur_state
!= svf_para
.runtest_run_state
)
1272 svf_add_statemove(svf_para
.runtest_run_state
);
1275 // call jtag_add_clocks
1276 jtag_add_clocks(run_count
);
1278 // move to end_state if necessary
1279 if (svf_para
.runtest_end_state
!= svf_para
.runtest_run_state
)
1281 svf_add_statemove(svf_para
.runtest_end_state
);
1284 if (svf_para
.runtest_run_state
!= TAP_IDLE
)
1286 // RUNTEST can only executed in TAP_IDLE
1287 LOG_ERROR("cannot runtest in %s state", svf_tap_state_name
[svf_para
.runtest_run_state
]);
1291 jtag_add_runtest(run_count
, svf_para
.runtest_end_state
);
1297 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i
, num_of_argu
);
1302 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1303 if (num_of_argu
< 2)
1305 LOG_ERROR("invalid parameter of %s", argus
[0]);
1308 if (num_of_argu
> 2)
1310 // STATE pathstate1 ... stable_state
1311 path
= (tap_state_t
*)malloc((num_of_argu
- 1) * sizeof(tap_state_t
));
1314 LOG_ERROR("not enough memory");
1317 num_of_argu
--; // num of path
1318 i_tmp
= 1; // path is from patameter 1
1319 for (i
= 0; i
< num_of_argu
; i
++)
1321 path
[i
] = svf_find_string_in_array(argus
[i_tmp
++], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1322 if (!svf_tap_state_is_valid(path
[i
]))
1324 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[i
]]);
1327 if (TAP_RESET
== path
[i
])
1331 jtag_add_pathmove(i
, path
);
1334 num_of_argu
-= i
+ 1;
1338 if (num_of_argu
> 0)
1340 // execute last path if necessary
1341 if (svf_tap_state_is_stable(path
[num_of_argu
- 1]))
1343 // last state MUST be stable state
1344 // TODO: call path_move
1345 jtag_add_pathmove(num_of_argu
, path
);
1346 LOG_DEBUG("\tmove to %s by path_move", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1350 LOG_ERROR("%s is not valid state", svf_tap_state_name
[path
[num_of_argu
- 1]]);
1354 // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1363 // STATE stable_state
1364 state
= svf_find_string_in_array(argus
[1], (char **)svf_tap_state_name
, dimof(svf_tap_state_name
));
1365 if (svf_tap_state_is_stable(state
))
1367 // TODO: move to state
1368 svf_add_statemove(state
);
1370 LOG_DEBUG("\tmove to %s by svf_add_statemove", svf_tap_state_name
[state
]);
1374 LOG_ERROR("%s is not valid state", svf_tap_state_name
[state
]);
1381 if (num_of_argu
!= 2)
1383 LOG_ERROR("invalid parameter of %s", argus
[0]);
1386 if (svf_para
.trst_mode
!= TRST_ABSENT
)
1388 if (ERROR_OK
!= svf_execute_tap())
1392 i_tmp
= svf_find_string_in_array(argus
[1], (char **)svf_trst_mode_name
, dimof(svf_trst_mode_name
));
1396 jtag_add_reset(1, 0);
1400 jtag_add_reset(0, 0);
1405 LOG_ERROR("unknown TRST mode: %s", argus
[1]);
1408 svf_para
.trst_mode
= i_tmp
;
1409 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name
[svf_para
.trst_mode
]);
1413 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1418 LOG_ERROR("invalid svf command: %s", argus
[0]);
1423 if (debug_level
>= LOG_LVL_DEBUG
)
1425 // for convenient debugging, execute tap if possible
1426 if ((svf_buffer_index
> 0) && \
1427 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1428 ((command
== STATE
) && (num_of_argu
== 2))))
1430 if (ERROR_OK
!= svf_execute_tap())
1435 // output debug info
1436 if ((SIR
== command
) || (SDR
== command
))
1439 memcpy(&read_value
, svf_tdi_buffer
, sizeof(int));
1440 // in debug mode, data is from index 0
1441 int read_mask
= svf_get_mask_u32(svf_check_tdo_para
[0].bit_len
);
1442 LOG_DEBUG("\tTDO read = 0x%X", read_value
& read_mask
);
1448 // for fast executing, execute tap if necessary
1449 // half of the buffer is for the next command
1450 if (((svf_buffer_index
>= SVF_MAX_BUFFER_SIZE_TO_COMMIT
) || (svf_check_tdo_para_index
>= SVF_CHECK_TDO_PARA_SIZE
/ 2)) && \
1451 (((command
!= STATE
) && (command
!= RUNTEST
)) || \
1452 ((command
== STATE
) && (num_of_argu
== 2))))
1454 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)