Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
SVF/XSVF: comment and whitespace fixes
[openocd.git] / src / svf / svf.c
1 /*
2 * Copyright (C) 2009 by Simon Qian
3 * SimonQian@SimonQian.com
4 *
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.
9 *
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.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20
21 /* The specification for SVF is available here:
22 * http://www.asset-intertech.com/support/svf.pdf
23 * Below, this document is refered to as the "SVF spec".
24 *
25 * The specification for XSVF is available here:
26 * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
27 * Below, this document is refered to as the "XSVF spec".
28 */
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #include "svf.h"
35 #include "jtag.h"
36 #include "time_support.h"
37
38
39 // SVF command
40 typedef enum
41 {
42 ENDDR,
43 ENDIR,
44 FREQUENCY,
45 HDR,
46 HIR,
47 PIO,
48 PIOMAP,
49 RUNTEST,
50 SDR,
51 SIR,
52 STATE,
53 TDR,
54 TIR,
55 TRST,
56 }svf_command_t;
57
58 const char *svf_command_name[14] =
59 {
60 "ENDDR",
61 "ENDIR",
62 "FREQUENCY",
63 "HDR",
64 "HIR",
65 "PIO",
66 "PIOMAP",
67 "RUNTEST",
68 "SDR",
69 "SIR",
70 "STATE",
71 "TDR",
72 "TIR",
73 "TRST"
74 };
75
76 typedef enum
77 {
78 TRST_ON,
79 TRST_OFF,
80 TRST_Z,
81 TRST_ABSENT
82 }trst_mode_t;
83
84 const char *svf_trst_mode_name[4] =
85 {
86 "ON",
87 "OFF",
88 "Z",
89 "ABSENT"
90 };
91
92 typedef struct
93 {
94 tap_state_t from;
95 tap_state_t to;
96 uint32_t num_of_moves;
97 tap_state_t paths[8];
98 }svf_statemove_t;
99
100 /*
101 * These paths are from the SVF specification for the STATE command, to be
102 * used when the STATE command only includes the final state. The first
103 * element of the path is the "from" (current) state, and the last one is
104 * the "to" (target) state.
105 *
106 * All specified paths are the shortest ones in the JTAG spec, and are thus
107 * not (!!) exact matches for the paths used elsewhere in OpenOCD. Note
108 * that PAUSE-to-PAUSE transitions all go through UPDATE and then CAPTURE,
109 * which has specific effects on the various registers; they are not NOPs.
110 *
111 * Paths to RESET are disabled here. As elsewhere in OpenOCD, and in XSVF
112 * and many SVF implementations, we don't want to risk missing that state.
113 * To get to RESET, always we ignore the current state.
114 */
115 static const svf_statemove_t svf_statemoves[] =
116 {
117 // from to num_of_moves, paths[8]
118 // {TAP_RESET, TAP_RESET, 1, {TAP_RESET}},
119 {TAP_RESET, TAP_IDLE, 2, {TAP_RESET, TAP_IDLE}},
120 {TAP_RESET, TAP_DRPAUSE, 6, {TAP_RESET, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
121 {TAP_RESET, TAP_IRPAUSE, 7, {TAP_RESET, TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}},
122
123 // {TAP_IDLE, TAP_RESET, 4, {TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
124 {TAP_IDLE, TAP_IDLE, 1, {TAP_IDLE}},
125 {TAP_IDLE, TAP_DRPAUSE, 5, {TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
126 {TAP_IDLE, TAP_IRPAUSE, 6, {TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}},
127
128 // {TAP_DRPAUSE, TAP_RESET, 6, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
129 {TAP_DRPAUSE, TAP_IDLE, 4, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE}},
130 {TAP_DRPAUSE, TAP_DRPAUSE, 7, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
131 {TAP_DRPAUSE, TAP_IRPAUSE, 8, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}},
132
133 // {TAP_IRPAUSE, TAP_RESET, 6, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
134 {TAP_IRPAUSE, TAP_IDLE, 4, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_IDLE}},
135 {TAP_IRPAUSE, TAP_DRPAUSE, 7, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
136 {TAP_IRPAUSE, TAP_IRPAUSE, 8, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}}
137 };
138
139 char *svf_tap_state_name[TAP_NUM_STATES];
140
141 #define XXR_TDI (1 << 0)
142 #define XXR_TDO (1 << 1)
143 #define XXR_MASK (1 << 2)
144 #define XXR_SMASK (1 << 3)
145 typedef struct
146 {
147 int len;
148 int data_mask;
149 uint8_t *tdi;
150 uint8_t *tdo;
151 uint8_t *mask;
152 uint8_t *smask;
153 }svf_xxr_para_t;
154
155 typedef struct
156 {
157 float frequency;
158 tap_state_t ir_end_state;
159 tap_state_t dr_end_state;
160 tap_state_t runtest_run_state;
161 tap_state_t runtest_end_state;
162 trst_mode_t trst_mode;
163
164 svf_xxr_para_t hir_para;
165 svf_xxr_para_t hdr_para;
166 svf_xxr_para_t tir_para;
167 svf_xxr_para_t tdr_para;
168 svf_xxr_para_t sir_para;
169 svf_xxr_para_t sdr_para;
170 }svf_para_t;
171
172 svf_para_t svf_para;
173 const svf_para_t svf_para_init =
174 {
175 // frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode
176 0, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TRST_Z,
177 // hir_para
178 // {len, data_mask, tdi, tdo, mask, smask},
179 {0, 0, NULL, NULL, NULL, NULL},
180 // hdr_para
181 // {len, data_mask, tdi, tdo, mask, smask},
182 {0, 0, NULL, NULL, NULL, NULL},
183 // tir_para
184 // {len, data_mask, tdi, tdo, mask, smask},
185 {0, 0, NULL, NULL, NULL, NULL},
186 // tdr_para
187 // {len, data_mask, tdi, tdo, mask, smask},
188 {0, 0, NULL, NULL, NULL, NULL},
189 // sir_para
190 // {len, data_mask, tdi, tdo, mask, smask},
191 {0, 0, NULL, NULL, NULL, NULL},
192 // sdr_para
193 // {len, data_mask, tdi, tdo, mask, smask},
194 {0, 0, NULL, NULL, NULL, NULL},
195 };
196
197 typedef struct
198 {
199 int line_num; // used to record line number of the check operation
200 // so more information could be printed
201 int enabled; // check is enabled or not
202 int buffer_offset; // buffer_offset to buffers
203 int bit_len; // bit length to check
204 }svf_check_tdo_para_t;
205
206 #define SVF_CHECK_TDO_PARA_SIZE 1024
207 static svf_check_tdo_para_t *svf_check_tdo_para = NULL;
208 static int svf_check_tdo_para_index = 0;
209
210 #define dimof(a) (sizeof(a) / sizeof((a)[0]))
211
212 static int svf_read_command_from_file(int fd);
213 static int svf_check_tdo(void);
214 static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len);
215 static int svf_run_command(struct command_context_s *cmd_ctx, char *cmd_str);
216 static int handle_svf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
217
218 static int svf_fd = 0;
219 static char *svf_command_buffer = NULL;
220 static int svf_command_buffer_size = 0;
221 static int svf_line_number = 1;
222
223 static jtag_tap_t *tap = NULL;
224
225 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (4 * 1024)
226 static uint8_t *svf_tdi_buffer = NULL, *svf_tdo_buffer = NULL, *svf_mask_buffer = NULL;
227 static int svf_buffer_index = 0, svf_buffer_size = 0;
228 static int svf_quiet = 0;
229
230
231 int svf_register_commands(struct command_context_s *cmd_ctx)
232 {
233 register_command(cmd_ctx, NULL, "svf", handle_svf_command,
234 COMMAND_EXEC, "run svf <file>");
235
236 return ERROR_OK;
237 }
238
239 void svf_free_xxd_para(svf_xxr_para_t *para)
240 {
241 if (NULL != para)
242 {
243 if (para->tdi != NULL)
244 {
245 free(para->tdi);
246 para->tdi = NULL;
247 }
248 if (para->tdo != NULL)
249 {
250 free(para->tdo);
251 para->tdo = NULL;
252 }
253 if (para->mask != NULL)
254 {
255 free(para->mask);
256 para->mask = NULL;
257 }
258 if (para->smask != NULL)
259 {
260 free(para->smask);
261 para->smask = NULL;
262 }
263 }
264 }
265
266 unsigned svf_get_mask_u32(int bitlen)
267 {
268 uint32_t bitmask;
269
270 if (bitlen < 0)
271 {
272 bitmask = 0;
273 }
274 else if (bitlen >= 32)
275 {
276 bitmask = 0xFFFFFFFF;
277 }
278 else
279 {
280 bitmask = (1 << bitlen) - 1;
281 }
282
283 return bitmask;
284 }
285
286 static const char* tap_state_svf_name(tap_state_t state)
287 {
288 const char* ret;
289
290 switch (state)
291 {
292 case TAP_RESET: ret = "RESET"; break;
293 case TAP_IDLE: ret = "IDLE"; break;
294 case TAP_DRSELECT: ret = "DRSELECT"; break;
295 case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
296 case TAP_DRSHIFT: ret = "DRSHIFT"; break;
297 case TAP_DREXIT1: ret = "DREXIT1"; break;
298 case TAP_DRPAUSE: ret = "DRPAUSE"; break;
299 case TAP_DREXIT2: ret = "DREXIT2"; break;
300 case TAP_DRUPDATE: ret = "DRUPDATE"; break;
301 case TAP_IRSELECT: ret = "IRSELECT"; break;
302 case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
303 case TAP_IRSHIFT: ret = "IRSHIFT"; break;
304 case TAP_IREXIT1: ret = "IREXIT1"; break;
305 case TAP_IRPAUSE: ret = "IRPAUSE"; break;
306 case TAP_IREXIT2: ret = "IREXIT2"; break;
307 case TAP_IRUPDATE: ret = "IRUPDATE"; break;
308 default: ret = "???"; break;
309 }
310
311 return ret;
312 }
313
314 static int svf_add_statemove(tap_state_t state_to)
315 {
316 tap_state_t state_from = cmd_queue_cur_state;
317 uint8_t index;
318
319 for (index = 0; index < dimof(svf_statemoves); index++)
320 {
321 if ((svf_statemoves[index].from == state_from)
322 && (svf_statemoves[index].to == state_to))
323 {
324 if (TAP_RESET == state_from)
325 {
326 jtag_add_tlr();
327 if (svf_statemoves[index].num_of_moves > 1)
328 {
329 jtag_add_pathmove(svf_statemoves[index].num_of_moves - 1, svf_statemoves[index].paths + 1);
330 }
331 }
332 else
333 {
334 if (svf_statemoves[index].num_of_moves > 0)
335 {
336 jtag_add_pathmove(svf_statemoves[index].num_of_moves, svf_statemoves[index].paths);
337 }
338 }
339 return ERROR_OK;
340 }
341 }
342 LOG_ERROR("can not move to %s", tap_state_svf_name(state_to));
343 return ERROR_FAIL;
344 }
345
346 static int handle_svf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
347 {
348 #define SVF_NUM_OF_OPTIONS 1
349 int command_num = 0, i;
350 int ret = ERROR_OK;
351 long long time_ago;
352
353 if ((argc < 1) || (argc > (1 + SVF_NUM_OF_OPTIONS)))
354 {
355 command_print(cmd_ctx, "usage: svf <file> [quiet]");
356 return ERROR_FAIL;
357 }
358
359 // parse variant
360 svf_quiet = 0;
361 for (i = 1; i < argc; i++)
362 {
363 if (!strcmp(args[i], "quiet"))
364 {
365 svf_quiet = 1;
366 }
367 else
368 {
369 LOG_ERROR("unknown variant for svf: %s", args[i]);
370
371 // no need to free anything now
372 return ERROR_FAIL;
373 }
374 }
375
376 if ((svf_fd = open(args[0], O_RDONLY)) < 0)
377 {
378 command_print(cmd_ctx, "file \"%s\" not found", args[0]);
379
380 // no need to free anything now
381 return ERROR_FAIL;
382 }
383
384 LOG_USER("svf processing file: \"%s\"", args[0]);
385
386 // get time
387 time_ago = timeval_ms();
388
389 // init
390 svf_line_number = 1;
391 svf_command_buffer_size = 0;
392
393 svf_check_tdo_para_index = 0;
394 svf_check_tdo_para = malloc(sizeof(svf_check_tdo_para_t) * SVF_CHECK_TDO_PARA_SIZE);
395 if (NULL == svf_check_tdo_para)
396 {
397 LOG_ERROR("not enough memory");
398 ret = ERROR_FAIL;
399 goto free_all;
400 }
401
402 svf_buffer_index = 0;
403 // double the buffer size
404 // in case current command cannot be commited, and next command is a bit scan command
405 // here is 32K bits for this big scan command, it should be enough
406 // buffer will be reallocated if buffer size is not enough
407 svf_tdi_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
408 if (NULL == svf_tdi_buffer)
409 {
410 LOG_ERROR("not enough memory");
411 ret = ERROR_FAIL;
412 goto free_all;
413 }
414 svf_tdo_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
415 if (NULL == svf_tdo_buffer)
416 {
417 LOG_ERROR("not enough memory");
418 ret = ERROR_FAIL;
419 goto free_all;
420 }
421 svf_mask_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
422 if (NULL == svf_mask_buffer)
423 {
424 LOG_ERROR("not enough memory");
425 ret = ERROR_FAIL;
426 goto free_all;
427 }
428 svf_buffer_size = 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT;
429
430 memcpy(&svf_para, &svf_para_init, sizeof(svf_para));
431 for (i = 0; i < (int)dimof(svf_tap_state_name); i++)
432 {
433 svf_tap_state_name[i] = (char *)tap_state_svf_name(i);
434 }
435
436 // TAP_RESET
437 jtag_add_tlr();
438
439 while (ERROR_OK == svf_read_command_from_file(svf_fd))
440 {
441 if (ERROR_OK != svf_run_command(cmd_ctx, svf_command_buffer))
442 {
443 LOG_ERROR("fail to run command at line %d", svf_line_number);
444 ret = ERROR_FAIL;
445 break;
446 }
447 command_num++;
448 }
449 if (ERROR_OK != jtag_execute_queue())
450 {
451 ret = ERROR_FAIL;
452 }
453 else if (ERROR_OK != svf_check_tdo())
454 {
455 ret = ERROR_FAIL;
456 }
457
458 // print time
459 command_print(cmd_ctx, "%lld ms used", timeval_ms() - time_ago);
460
461 free_all:
462
463 close(svf_fd);
464 svf_fd = 0;
465
466 // free buffers
467 if (svf_command_buffer)
468 {
469 free(svf_command_buffer);
470 svf_command_buffer = NULL;
471 svf_command_buffer_size = 0;
472 }
473 if (svf_check_tdo_para)
474 {
475 free(svf_check_tdo_para);
476 svf_check_tdo_para = NULL;
477 svf_check_tdo_para_index = 0;
478 }
479 if (svf_tdi_buffer)
480 {
481 free(svf_tdi_buffer);
482 svf_tdi_buffer = NULL;
483 }
484 if (svf_tdo_buffer)
485 {
486 free(svf_tdo_buffer);
487 svf_tdo_buffer = NULL;
488 }
489 if (svf_mask_buffer)
490 {
491 free(svf_mask_buffer);
492 svf_mask_buffer = NULL;
493 }
494 svf_buffer_index = 0;
495 svf_buffer_size = 0;
496
497 svf_free_xxd_para(&svf_para.hdr_para);
498 svf_free_xxd_para(&svf_para.hir_para);
499 svf_free_xxd_para(&svf_para.tdr_para);
500 svf_free_xxd_para(&svf_para.tir_para);
501 svf_free_xxd_para(&svf_para.sdr_para);
502 svf_free_xxd_para(&svf_para.sir_para);
503
504 if (ERROR_OK == ret)
505 {
506 command_print(cmd_ctx, "svf file programmed successfully for %d commands", command_num);
507 }
508 else
509 {
510 command_print(cmd_ctx, "svf file programmed failed");
511 }
512
513 return ret;
514 }
515
516 #define SVFP_CMD_INC_CNT 1024
517 static int svf_read_command_from_file(int fd)
518 {
519 char ch, *tmp_buffer = NULL;
520 int cmd_pos = 0, cmd_ok = 0, slash = 0, comment = 0;
521
522 while (!cmd_ok && (read(fd, &ch, 1) > 0))
523 {
524 switch (ch)
525 {
526 case '!':
527 slash = 0;
528 comment = 1;
529 break;
530 case '/':
531 if (++slash == 2)
532 {
533 comment = 1;
534 }
535 break;
536 case ';':
537 slash = 0;
538 if (!comment)
539 {
540 cmd_ok = 1;
541 }
542 break;
543 case '\n':
544 svf_line_number++;
545 case '\r':
546 slash = 0;
547 comment = 0;
548 break;
549 default:
550 if (!comment)
551 {
552 if (cmd_pos >= svf_command_buffer_size - 1)
553 {
554 tmp_buffer = (char*)malloc(svf_command_buffer_size + SVFP_CMD_INC_CNT); // 1 more byte for '\0'
555 if (NULL == tmp_buffer)
556 {
557 LOG_ERROR("not enough memory");
558 return ERROR_FAIL;
559 }
560 if (svf_command_buffer_size > 0)
561 {
562 memcpy(tmp_buffer, svf_command_buffer, svf_command_buffer_size);
563 }
564 if (svf_command_buffer != NULL)
565 {
566 free(svf_command_buffer);
567 }
568 svf_command_buffer = tmp_buffer;
569 svf_command_buffer_size += SVFP_CMD_INC_CNT;
570 tmp_buffer = NULL;
571 }
572 svf_command_buffer[cmd_pos++] = (char)toupper(ch);
573 }
574 break;
575 }
576 }
577
578 if (cmd_ok)
579 {
580 svf_command_buffer[cmd_pos] = '\0';
581 return ERROR_OK;
582 }
583 else
584 {
585 return ERROR_FAIL;
586 }
587 }
588
589 static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_argu)
590 {
591 int pos = 0, num = 0, space_found = 1;
592
593 while (pos < len)
594 {
595 switch (str[pos])
596 {
597 case '\n':
598 case '\r':
599 case '!':
600 case '/':
601 LOG_ERROR("fail to parse svf command");
602 return ERROR_FAIL;
603 break;
604 case ' ':
605 space_found = 1;
606 str[pos] = '\0';
607 break;
608 default:
609 if (space_found)
610 {
611 argus[num++] = &str[pos];
612 space_found = 0;
613 }
614 break;
615 }
616 pos++;
617 }
618
619 *num_of_argu = num;
620
621 return ERROR_OK;
622 }
623
624 static int svf_tap_state_is_stable(tap_state_t state)
625 {
626 return ((TAP_RESET == state) || (TAP_IDLE == state) || (TAP_DRPAUSE == state) || (TAP_IRPAUSE == state));
627 }
628
629 static int svf_tap_state_is_valid(tap_state_t state)
630 {
631 return state >= 0 && state < TAP_NUM_STATES;
632 }
633
634 static int svf_find_string_in_array(char *str, char **strs, int num_of_element)
635 {
636 int i;
637
638 for (i = 0; i < num_of_element; i++)
639 {
640 if (!strcmp(str, strs[i]))
641 {
642 return i;
643 }
644 }
645 return 0xFF;
646 }
647
648 static int svf_adjust_array_length(uint8_t **arr, int orig_bit_len, int new_bit_len)
649 {
650 int new_byte_len = (new_bit_len + 7) >> 3;
651
652 if ((NULL == *arr) || (((orig_bit_len + 7) >> 3) < ((new_bit_len + 7) >> 3)))
653 {
654 if (*arr != NULL)
655 {
656 free(*arr);
657 *arr = NULL;
658 }
659 *arr = (uint8_t*)malloc(new_byte_len);
660 if (NULL == *arr)
661 {
662 LOG_ERROR("not enough memory");
663 return ERROR_FAIL;
664 }
665 memset(*arr, 0, new_byte_len);
666 }
667 return ERROR_OK;
668 }
669
670 static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_len, int bit_len)
671 {
672 int i, str_len = strlen(str), str_hbyte_len = (bit_len + 3) >> 2;
673 uint8_t ch = 0;
674
675 if (ERROR_OK != svf_adjust_array_length(bin, orig_bit_len, bit_len))
676 {
677 LOG_ERROR("fail to adjust length of array");
678 return ERROR_FAIL;
679 }
680
681 for (i = 0; i < str_hbyte_len; i++)
682 {
683 ch = 0;
684 while (str_len > 0)
685 {
686 ch = str[--str_len];
687
688 if (!isblank(ch))
689 {
690 if ((ch >= '0') && (ch <= '9'))
691 {
692 ch = ch - '0';
693 break;
694 }
695 else if ((ch >= 'A') && (ch <= 'F'))
696 {
697 ch = ch - 'A' + 10;
698 break;
699 }
700 else
701 {
702 LOG_ERROR("invalid hex string");
703 return ERROR_FAIL;
704 }
705 }
706
707 ch = 0;
708 }
709
710 // write bin
711 if (i % 2)
712 {
713 // MSB
714 (*bin)[i / 2] |= ch << 4;
715 }
716 else
717 {
718 // LSB
719 (*bin)[i / 2] = 0;
720 (*bin)[i / 2] |= ch;
721 }
722 }
723
724 // check valid
725 if (str_len > 0 || (ch & ~((1 << (4 - (bit_len % 4))) - 1)) != 0)
726 {
727 LOG_ERROR("value execede length");
728 return ERROR_FAIL;
729 }
730
731 return ERROR_OK;
732 }
733
734 static int svf_check_tdo(void)
735 {
736 int i, len, index;
737
738 for (i = 0; i < svf_check_tdo_para_index; i++)
739 {
740 index = svf_check_tdo_para[i].buffer_offset;
741 len = svf_check_tdo_para[i].bit_len;
742 if ((svf_check_tdo_para[i].enabled)
743 && buf_cmp_mask(&svf_tdi_buffer[index], &svf_tdo_buffer[index], &svf_mask_buffer[index], len))
744 {
745 unsigned bitmask;
746 unsigned received, expected, tapmask;
747 bitmask = svf_get_mask_u32(svf_check_tdo_para[i].bit_len);
748
749 memcpy(&received, svf_tdi_buffer + index, sizeof(unsigned));
750 memcpy(&expected, svf_tdo_buffer + index, sizeof(unsigned));
751 memcpy(&tapmask, svf_mask_buffer + index, sizeof(unsigned));
752 LOG_ERROR("tdo check error at line %d",
753 svf_check_tdo_para[i].line_num);
754 LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
755 received & bitmask,
756 expected & bitmask,
757 tapmask & bitmask);
758 return ERROR_FAIL;
759 }
760 }
761 svf_check_tdo_para_index = 0;
762
763 return ERROR_OK;
764 }
765
766 static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len)
767 {
768 if (svf_check_tdo_para_index >= SVF_CHECK_TDO_PARA_SIZE)
769 {
770 LOG_ERROR("toooooo many operation undone");
771 return ERROR_FAIL;
772 }
773
774 svf_check_tdo_para[svf_check_tdo_para_index].line_num = svf_line_number;
775 svf_check_tdo_para[svf_check_tdo_para_index].bit_len = bit_len;
776 svf_check_tdo_para[svf_check_tdo_para_index].enabled = enabled;
777 svf_check_tdo_para[svf_check_tdo_para_index].buffer_offset = buffer_offset;
778 svf_check_tdo_para_index++;
779
780 return ERROR_OK;
781 }
782
783 static int svf_execute_tap(void)
784 {
785 if (ERROR_OK != jtag_execute_queue())
786 {
787 return ERROR_FAIL;
788 }
789 else if (ERROR_OK != svf_check_tdo())
790 {
791 return ERROR_FAIL;
792 }
793
794 svf_buffer_index = 0;
795
796 return ERROR_OK;
797 }
798
799 static int svf_run_command(struct command_context_s *cmd_ctx, char *cmd_str)
800 {
801 char *argus[256], command;
802 int num_of_argu = 0, i;
803
804 // tmp variable
805 int i_tmp;
806
807 // for RUNTEST
808 int run_count;
809 float min_time, max_time;
810 // for XXR
811 svf_xxr_para_t *xxr_para_tmp;
812 uint8_t **pbuffer_tmp;
813 scan_field_t field;
814 // for STATE
815 tap_state_t *path = NULL, state;
816
817 if (!svf_quiet)
818 {
819 LOG_USER("%s", svf_command_buffer);
820 }
821
822 if (ERROR_OK != svf_parse_cmd_string(cmd_str, strlen(cmd_str), argus, &num_of_argu))
823 {
824 return ERROR_FAIL;
825 }
826
827 command = svf_find_string_in_array(argus[0], (char **)svf_command_name, dimof(svf_command_name));
828 switch (command)
829 {
830 case ENDDR:
831 case ENDIR:
832 if (num_of_argu != 2)
833 {
834 LOG_ERROR("invalid parameter of %s", argus[0]);
835 return ERROR_FAIL;
836 }
837 i_tmp = svf_find_string_in_array(argus[1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
838 if (svf_tap_state_is_stable(i_tmp))
839 {
840 if (command == ENDIR)
841 {
842 svf_para.ir_end_state = i_tmp;
843 LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name[svf_para.ir_end_state]);
844 }
845 else
846 {
847 svf_para.dr_end_state = i_tmp;
848 LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name[svf_para.dr_end_state]);
849 }
850 }
851 else
852 {
853 LOG_ERROR("%s is not valid state", argus[1]);
854 return ERROR_FAIL;
855 }
856 break;
857 case FREQUENCY:
858 if ((num_of_argu != 1) && (num_of_argu != 3))
859 {
860 LOG_ERROR("invalid parameter of %s", argus[0]);
861 return ERROR_FAIL;
862 }
863 if (1 == num_of_argu)
864 {
865 // TODO: set jtag speed to full speed
866 svf_para.frequency = 0;
867 }
868 else
869 {
870 if (strcmp(argus[2], "HZ"))
871 {
872 LOG_ERROR("HZ not found in FREQUENCY command");
873 return ERROR_FAIL;
874 }
875 if (ERROR_OK != svf_execute_tap())
876 {
877 return ERROR_FAIL;
878 }
879 svf_para.frequency = atof(argus[1]);
880 // TODO: set jtag speed to
881 if (svf_para.frequency > 0)
882 {
883 command_run_linef(cmd_ctx, "jtag_khz %d", (int)svf_para.frequency / 1000);
884 LOG_DEBUG("\tfrequency = %f", svf_para.frequency);
885 }
886 }
887 break;
888 case HDR:
889 xxr_para_tmp = &svf_para.hdr_para;
890 goto XXR_common;
891 case HIR:
892 xxr_para_tmp = &svf_para.hir_para;
893 goto XXR_common;
894 case TDR:
895 xxr_para_tmp = &svf_para.tdr_para;
896 goto XXR_common;
897 case TIR:
898 xxr_para_tmp = &svf_para.tir_para;
899 goto XXR_common;
900 case SDR:
901 xxr_para_tmp = &svf_para.sdr_para;
902 goto XXR_common;
903 case SIR:
904 xxr_para_tmp = &svf_para.sir_para;
905 goto XXR_common;
906 XXR_common:
907 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
908 if ((num_of_argu > 10) || (num_of_argu % 2))
909 {
910 LOG_ERROR("invalid parameter of %s", argus[0]);
911 return ERROR_FAIL;
912 }
913 i_tmp = xxr_para_tmp->len;
914 xxr_para_tmp->len = atoi(argus[1]);
915 LOG_DEBUG("\tlength = %d", xxr_para_tmp->len);
916 xxr_para_tmp->data_mask = 0;
917 for (i = 2; i < num_of_argu; i += 2)
918 {
919 if ((strlen(argus[i + 1]) < 3) || (argus[i + 1][0] != '(') || (argus[i + 1][strlen(argus[i + 1]) - 1] != ')'))
920 {
921 LOG_ERROR("data section error");
922 return ERROR_FAIL;
923 }
924 argus[i + 1][strlen(argus[i + 1]) - 1] = '\0';
925 // TDI, TDO, MASK, SMASK
926 if (!strcmp(argus[i], "TDI"))
927 {
928 // TDI
929 pbuffer_tmp = &xxr_para_tmp->tdi;
930 xxr_para_tmp->data_mask |= XXR_TDI;
931 }
932 else if (!strcmp(argus[i], "TDO"))
933 {
934 // TDO
935 pbuffer_tmp = &xxr_para_tmp->tdo;
936 xxr_para_tmp->data_mask |= XXR_TDO;
937 }
938 else if (!strcmp(argus[i], "MASK"))
939 {
940 // MASK
941 pbuffer_tmp = &xxr_para_tmp->mask;
942 xxr_para_tmp->data_mask |= XXR_MASK;
943 }
944 else if (!strcmp(argus[i], "SMASK"))
945 {
946 // SMASK
947 pbuffer_tmp = &xxr_para_tmp->smask;
948 xxr_para_tmp->data_mask |= XXR_SMASK;
949 }
950 else
951 {
952 LOG_ERROR("unknow parameter: %s", argus[i]);
953 return ERROR_FAIL;
954 }
955 if (ERROR_OK != svf_copy_hexstring_to_binary(&argus[i + 1][1], pbuffer_tmp, i_tmp, xxr_para_tmp->len))
956 {
957 LOG_ERROR("fail to parse hex value");
958 return ERROR_FAIL;
959 }
960 LOG_DEBUG("\t%s = 0x%X", argus[i], (**(int**)pbuffer_tmp) & svf_get_mask_u32(xxr_para_tmp->len));
961 }
962 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
963 // the mask pattern used is all cares
964 if (!(xxr_para_tmp->data_mask & XXR_MASK) && (i_tmp != xxr_para_tmp->len))
965 {
966 // MASK not defined and length changed
967 if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len))
968 {
969 LOG_ERROR("fail to adjust length of array");
970 return ERROR_FAIL;
971 }
972 buf_set_ones(xxr_para_tmp->mask, xxr_para_tmp->len);
973 }
974 // If TDO is absent, no comparison is needed, set the mask to 0
975 if (!(xxr_para_tmp->data_mask & XXR_TDO))
976 {
977 if (NULL == xxr_para_tmp->tdo)
978 {
979 if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->tdo, i_tmp, xxr_para_tmp->len))
980 {
981 LOG_ERROR("fail to adjust length of array");
982 return ERROR_FAIL;
983 }
984 }
985 if (NULL == xxr_para_tmp->mask)
986 {
987 if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len))
988 {
989 LOG_ERROR("fail to adjust length of array");
990 return ERROR_FAIL;
991 }
992 }
993 memset(xxr_para_tmp->mask, 0, (xxr_para_tmp->len + 7) >> 3);
994 }
995 // do scan if necessary
996 if (SDR == command)
997 {
998 // check buffer size first, reallocate if necessary
999 i = svf_para.hdr_para.len + svf_para.sdr_para.len + svf_para.tdr_para.len;
1000 if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3))
1001 {
1002 #if 1
1003 // simply print error message
1004 LOG_ERROR("buffer is not enough, report to author");
1005 return ERROR_FAIL;
1006 #else
1007 uint8_t *buffer_tmp;
1008
1009 // reallocate buffer
1010 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1011 if (NULL == buffer_tmp)
1012 {
1013 LOG_ERROR("not enough memory");
1014 return ERROR_FAIL;
1015 }
1016 memcpy(buffer_tmp, svf_tdi_buffer, svf_buffer_index);
1017 // svf_tdi_buffer isn't NULL here
1018 free(svf_tdi_buffer);
1019 svf_tdi_buffer = buffer_tmp;
1020
1021 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1022 if (NULL == buffer_tmp)
1023 {
1024 LOG_ERROR("not enough memory");
1025 return ERROR_FAIL;
1026 }
1027 memcpy(buffer_tmp, svf_tdo_buffer, svf_buffer_index);
1028 // svf_tdo_buffer isn't NULL here
1029 free(svf_tdo_buffer);
1030 svf_tdo_buffer = buffer_tmp;
1031
1032 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1033 if (NULL == buffer_tmp)
1034 {
1035 LOG_ERROR("not enough memory");
1036 return ERROR_FAIL;
1037 }
1038 memcpy(buffer_tmp, svf_mask_buffer, svf_buffer_index);
1039 // svf_mask_buffer isn't NULL here
1040 free(svf_mask_buffer);
1041 svf_mask_buffer = buffer_tmp;
1042
1043 buffer_tmp = NULL;
1044 svf_buffer_size = svf_buffer_index + ((i + 7) >> 3);
1045 #endif
1046 }
1047
1048 // assemble dr data
1049 i = 0;
1050 buf_set_buf(svf_para.hdr_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.hdr_para.len);
1051 i += svf_para.hdr_para.len;
1052 buf_set_buf(svf_para.sdr_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.sdr_para.len);
1053 i += svf_para.sdr_para.len;
1054 buf_set_buf(svf_para.tdr_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.tdr_para.len);
1055 i += svf_para.tdr_para.len;
1056
1057 // add check data
1058 if (svf_para.sdr_para.data_mask & XXR_TDO)
1059 {
1060 // assemble dr mask data
1061 i = 0;
1062 buf_set_buf(svf_para.hdr_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.hdr_para.len);
1063 i += svf_para.hdr_para.len;
1064 buf_set_buf(svf_para.sdr_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.sdr_para.len);
1065 i += svf_para.sdr_para.len;
1066 buf_set_buf(svf_para.tdr_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.tdr_para.len);
1067 i += svf_para.tdr_para.len;
1068 // assemble dr check data
1069 i = 0;
1070 buf_set_buf(svf_para.hdr_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.hdr_para.len);
1071 i += svf_para.hdr_para.len;
1072 buf_set_buf(svf_para.sdr_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.sdr_para.len);
1073 i += svf_para.sdr_para.len;
1074 buf_set_buf(svf_para.tdr_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.tdr_para.len);
1075 i += svf_para.tdr_para.len;
1076
1077 svf_add_check_para(1, svf_buffer_index, i);
1078 }
1079 else
1080 {
1081 svf_add_check_para(0, svf_buffer_index, i);
1082 }
1083 field.tap = tap;
1084 field.num_bits = i;
1085 field.out_value = &svf_tdi_buffer[svf_buffer_index];
1086 field.in_value = &svf_tdi_buffer[svf_buffer_index];
1087 jtag_add_plain_dr_scan(1, &field, svf_para.dr_end_state);
1088
1089 svf_buffer_index += (i + 7) >> 3;
1090 }
1091 else if (SIR == command)
1092 {
1093 // check buffer size first, reallocate if necessary
1094 i = svf_para.hir_para.len + svf_para.sir_para.len + svf_para.tir_para.len;
1095 if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3))
1096 {
1097 #if 1
1098 // simply print error message
1099 LOG_ERROR("buffer is not enough, report to author");
1100 return ERROR_FAIL;
1101 #else
1102 uint8_t *buffer_tmp;
1103
1104 // reallocate buffer
1105 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1106 if (NULL == buffer_tmp)
1107 {
1108 LOG_ERROR("not enough memory");
1109 return ERROR_FAIL;
1110 }
1111 memcpy(buffer_tmp, svf_tdi_buffer, svf_buffer_index);
1112 // svf_tdi_buffer isn't NULL here
1113 free(svf_tdi_buffer);
1114 svf_tdi_buffer = buffer_tmp;
1115
1116 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1117 if (NULL == buffer_tmp)
1118 {
1119 LOG_ERROR("not enough memory");
1120 return ERROR_FAIL;
1121 }
1122 memcpy(buffer_tmp, svf_tdo_buffer, svf_buffer_index);
1123 // svf_tdo_buffer isn't NULL here
1124 free(svf_tdo_buffer);
1125 svf_tdo_buffer = buffer_tmp;
1126
1127 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1128 if (NULL == buffer_tmp)
1129 {
1130 LOG_ERROR("not enough memory");
1131 return ERROR_FAIL;
1132 }
1133 memcpy(buffer_tmp, svf_mask_buffer, svf_buffer_index);
1134 // svf_mask_buffer isn't NULL here
1135 free(svf_mask_buffer);
1136 svf_mask_buffer = buffer_tmp;
1137
1138 buffer_tmp = NULL;
1139 svf_buffer_size = svf_buffer_index + ((i + 7) >> 3);
1140 #endif
1141 }
1142
1143 // assemble ir data
1144 i = 0;
1145 buf_set_buf(svf_para.hir_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.hir_para.len);
1146 i += svf_para.hir_para.len;
1147 buf_set_buf(svf_para.sir_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.sir_para.len);
1148 i += svf_para.sir_para.len;
1149 buf_set_buf(svf_para.tir_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.tir_para.len);
1150 i += svf_para.tir_para.len;
1151
1152 // add check data
1153 if (svf_para.sir_para.data_mask & XXR_TDO)
1154 {
1155 // assemble dr mask data
1156 i = 0;
1157 buf_set_buf(svf_para.hir_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.hir_para.len);
1158 i += svf_para.hir_para.len;
1159 buf_set_buf(svf_para.sir_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.sir_para.len);
1160 i += svf_para.sir_para.len;
1161 buf_set_buf(svf_para.tir_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.tir_para.len);
1162 i += svf_para.tir_para.len;
1163 // assemble dr check data
1164 i = 0;
1165 buf_set_buf(svf_para.hir_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.hir_para.len);
1166 i += svf_para.hir_para.len;
1167 buf_set_buf(svf_para.sir_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.sir_para.len);
1168 i += svf_para.sir_para.len;
1169 buf_set_buf(svf_para.tir_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.tir_para.len);
1170 i += svf_para.tir_para.len;
1171
1172 svf_add_check_para(1, svf_buffer_index, i);
1173 }
1174 else
1175 {
1176 svf_add_check_para(0, svf_buffer_index, i);
1177 }
1178 field.tap = tap;
1179 field.num_bits = i;
1180 field.out_value = &svf_tdi_buffer[svf_buffer_index];
1181 field.in_value = &svf_tdi_buffer[svf_buffer_index];
1182 jtag_add_plain_ir_scan(1, &field, svf_para.ir_end_state);
1183
1184 svf_buffer_index += (i + 7) >> 3;
1185 }
1186 break;
1187 case PIO:
1188 case PIOMAP:
1189 LOG_ERROR("PIO and PIOMAP are not supported");
1190 return ERROR_FAIL;
1191 break;
1192 case RUNTEST:
1193 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1194 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1195 if ((num_of_argu < 3) && (num_of_argu > 11))
1196 {
1197 LOG_ERROR("invalid parameter of %s", argus[0]);
1198 return ERROR_FAIL;
1199 }
1200 // init
1201 run_count = 0;
1202 min_time = 0;
1203 max_time = 0;
1204 i = 1;
1205 // run_state
1206 i_tmp = svf_find_string_in_array(argus[i], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1207 if (svf_tap_state_is_valid(i_tmp))
1208 {
1209 if (svf_tap_state_is_stable(i_tmp))
1210 {
1211 svf_para.runtest_run_state = i_tmp;
1212
1213 // When a run_state is specified, the new run_state becomes the default end_state
1214 svf_para.runtest_end_state = i_tmp;
1215 LOG_DEBUG("\trun_state = %s", svf_tap_state_name[svf_para.runtest_run_state]);
1216 i++;
1217 }
1218 else
1219 {
1220 LOG_ERROR("%s is not valid state", svf_tap_state_name[i_tmp]);
1221 return ERROR_FAIL;
1222 }
1223 }
1224 // run_count run_clk
1225 if (((i + 2) <= num_of_argu) && strcmp(argus[i + 1], "SEC"))
1226 {
1227 if (!strcmp(argus[i + 1], "TCK"))
1228 {
1229 // clock source is TCK
1230 run_count = atoi(argus[i]);
1231 LOG_DEBUG("\trun_count@TCK = %d", run_count);
1232 }
1233 else
1234 {
1235 LOG_ERROR("%s not supported for clock", argus[i + 1]);
1236 return ERROR_FAIL;
1237 }
1238 i += 2;
1239 }
1240 // min_time SEC
1241 if (((i + 2) <= num_of_argu) && !strcmp(argus[i + 1], "SEC"))
1242 {
1243 min_time = atof(argus[i]);
1244 LOG_DEBUG("\tmin_time = %fs", min_time);
1245 i += 2;
1246 }
1247 // MAXIMUM max_time SEC
1248 if (((i + 3) <= num_of_argu) && !strcmp(argus[i], "MAXIMUM") && !strcmp(argus[i + 2], "SEC"))
1249 {
1250 max_time = atof(argus[i + 1]);
1251 LOG_DEBUG("\tmax_time = %fs", max_time);
1252 i += 3;
1253 }
1254 // ENDSTATE end_state
1255 if (((i + 2) <= num_of_argu) && !strcmp(argus[i], "ENDSTATE"))
1256 {
1257 i_tmp = svf_find_string_in_array(argus[i + 1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1258 if (svf_tap_state_is_stable(i_tmp))
1259 {
1260 svf_para.runtest_end_state = i_tmp;
1261 LOG_DEBUG("\tend_state = %s", svf_tap_state_name[svf_para.runtest_end_state]);
1262 }
1263 else
1264 {
1265 LOG_ERROR("%s is not valid state", svf_tap_state_name[i_tmp]);
1266 return ERROR_FAIL;
1267 }
1268 i += 2;
1269 }
1270 // calculate run_count
1271 if ((0 == run_count) && (min_time > 0))
1272 {
1273 run_count = min_time * svf_para.frequency;
1274 }
1275 // all parameter should be parsed
1276 if (i == num_of_argu)
1277 {
1278 if (run_count > 0)
1279 {
1280 // run_state and end_state is checked to be stable state
1281 // TODO: do runtest
1282 #if 1
1283 // enter into run_state if necessary
1284 if (cmd_queue_cur_state != svf_para.runtest_run_state)
1285 {
1286 svf_add_statemove(svf_para.runtest_run_state);
1287 }
1288
1289 // call jtag_add_clocks
1290 jtag_add_clocks(run_count);
1291
1292 // move to end_state if necessary
1293 if (svf_para.runtest_end_state != svf_para.runtest_run_state)
1294 {
1295 svf_add_statemove(svf_para.runtest_end_state);
1296 }
1297 #else
1298 if (svf_para.runtest_run_state != TAP_IDLE)
1299 {
1300 // RUNTEST can only executed in TAP_IDLE
1301 LOG_ERROR("cannot runtest in %s state", svf_tap_state_name[svf_para.runtest_run_state]);
1302 return ERROR_FAIL;
1303 }
1304
1305 jtag_add_runtest(run_count, svf_para.runtest_end_state);
1306 #endif
1307 }
1308 }
1309 else
1310 {
1311 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i, num_of_argu);
1312 return ERROR_FAIL;
1313 }
1314 break;
1315 case STATE:
1316 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1317 if (num_of_argu < 2)
1318 {
1319 LOG_ERROR("invalid parameter of %s", argus[0]);
1320 return ERROR_FAIL;
1321 }
1322 if (num_of_argu > 2)
1323 {
1324 // STATE pathstate1 ... stable_state
1325 path = (tap_state_t *)malloc((num_of_argu - 1) * sizeof(tap_state_t));
1326 if (NULL == path)
1327 {
1328 LOG_ERROR("not enough memory");
1329 return ERROR_FAIL;
1330 }
1331 num_of_argu--; // num of path
1332 i_tmp = 1; // path is from patameter 1
1333 for (i = 0; i < num_of_argu; i++)
1334 {
1335 path[i] = svf_find_string_in_array(argus[i_tmp++], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1336 if (!svf_tap_state_is_valid(path[i]))
1337 {
1338 LOG_ERROR("%s is not valid state", svf_tap_state_name[path[i]]);
1339 free(path);
1340 return ERROR_FAIL;
1341 }
1342 if (TAP_RESET == path[i])
1343 {
1344 if (i > 0)
1345 {
1346 jtag_add_pathmove(i, path);
1347 }
1348 jtag_add_tlr();
1349 num_of_argu -= i + 1;
1350 i = -1;
1351 }
1352 }
1353 if (num_of_argu > 0)
1354 {
1355 // execute last path if necessary
1356 if (svf_tap_state_is_stable(path[num_of_argu - 1]))
1357 {
1358 // last state MUST be stable state
1359 // TODO: call path_move
1360 jtag_add_pathmove(num_of_argu, path);
1361 LOG_DEBUG("\tmove to %s by path_move", svf_tap_state_name[path[num_of_argu - 1]]);
1362 }
1363 else
1364 {
1365 LOG_ERROR("%s is not valid state", svf_tap_state_name[path[num_of_argu - 1]]);
1366 free(path);
1367 return ERROR_FAIL;
1368 }
1369 }
1370 // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1371 if (NULL != path)
1372 {
1373 free(path);
1374 path = NULL;
1375 }
1376 }
1377 else
1378 {
1379 // STATE stable_state
1380 state = svf_find_string_in_array(argus[1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1381 if (svf_tap_state_is_stable(state))
1382 {
1383 // TODO: move to state
1384 svf_add_statemove(state);
1385
1386 LOG_DEBUG("\tmove to %s by svf_add_statemove", svf_tap_state_name[state]);
1387 }
1388 else
1389 {
1390 LOG_ERROR("%s is not valid state", svf_tap_state_name[state]);
1391 return ERROR_FAIL;
1392 }
1393 }
1394 break;
1395 case TRST:
1396 // TRST trst_mode
1397 if (num_of_argu != 2)
1398 {
1399 LOG_ERROR("invalid parameter of %s", argus[0]);
1400 return ERROR_FAIL;
1401 }
1402 if (svf_para.trst_mode != TRST_ABSENT)
1403 {
1404 if (ERROR_OK != svf_execute_tap())
1405 {
1406 return ERROR_FAIL;
1407 }
1408 i_tmp = svf_find_string_in_array(argus[1], (char **)svf_trst_mode_name, dimof(svf_trst_mode_name));
1409 switch (i_tmp)
1410 {
1411 case TRST_ON:
1412 jtag_add_reset(1, 0);
1413 break;
1414 case TRST_Z:
1415 case TRST_OFF:
1416 jtag_add_reset(0, 0);
1417 break;
1418 case TRST_ABSENT:
1419 break;
1420 default:
1421 LOG_ERROR("unknown TRST mode: %s", argus[1]);
1422 return ERROR_FAIL;
1423 }
1424 svf_para.trst_mode = i_tmp;
1425 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name[svf_para.trst_mode]);
1426 }
1427 else
1428 {
1429 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1430 return ERROR_FAIL;
1431 }
1432 break;
1433 default:
1434 LOG_ERROR("invalid svf command: %s", argus[0]);
1435 return ERROR_FAIL;
1436 break;
1437 }
1438
1439 if (debug_level >= LOG_LVL_DEBUG)
1440 {
1441 // for convenient debugging, execute tap if possible
1442 if ((svf_buffer_index > 0) && \
1443 (((command != STATE) && (command != RUNTEST)) || \
1444 ((command == STATE) && (num_of_argu == 2))))
1445 {
1446 if (ERROR_OK != svf_execute_tap())
1447 {
1448 return ERROR_FAIL;
1449 }
1450
1451 // output debug info
1452 if ((SIR == command) || (SDR == command))
1453 {
1454 int read_value;
1455 memcpy(&read_value, svf_tdi_buffer, sizeof(int));
1456 // in debug mode, data is from index 0
1457 int read_mask = svf_get_mask_u32(svf_check_tdo_para[0].bit_len);
1458 LOG_DEBUG("\tTDO read = 0x%X", read_value & read_mask);
1459 }
1460 }
1461 }
1462 else
1463 {
1464 // for fast executing, execute tap if necessary
1465 // half of the buffer is for the next command
1466 if (((svf_buffer_index >= SVF_MAX_BUFFER_SIZE_TO_COMMIT) || (svf_check_tdo_para_index >= SVF_CHECK_TDO_PARA_SIZE / 2)) && \
1467 (((command != STATE) && (command != RUNTEST)) || \
1468 ((command == STATE) && (num_of_argu == 2))))
1469 {
1470 return svf_execute_tap();
1471 }
1472 }
1473
1474 return ERROR_OK;
1475 }
Open On-Chip Debugger

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)