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