Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
SVF: better spec conformance for STATE switch
[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 /* when resetting, be paranoid and ignore current state */
320 if (state_to == TAP_RESET) {
321 jtag_add_tlr();
322 return ERROR_OK;
323 }
324
325 for (index = 0; index < dimof(svf_statemoves); index++)
326 {
327 if ((svf_statemoves[index].from == state_from)
328 && (svf_statemoves[index].to == state_to))
329 {
330 /* recorded path includes current state ... avoid extra TCKs! */
331 if (svf_statemoves[index].num_of_moves > 1)
332 jtag_add_pathmove(svf_statemoves[index].num_of_moves - 1,
333 svf_statemoves[index].paths + 1);
334 else
335 jtag_add_pathmove(svf_statemoves[index].num_of_moves,
336 svf_statemoves[index].paths);
337 return ERROR_OK;
338 }
339 }
340 LOG_ERROR("SVF: can not move to %s", tap_state_svf_name(state_to));
341 return ERROR_FAIL;
342 }
343
344 static int handle_svf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
345 {
346 #define SVF_NUM_OF_OPTIONS 1
347 int command_num = 0, i;
348 int ret = ERROR_OK;
349 long long time_ago;
350
351 if ((argc < 1) || (argc > (1 + SVF_NUM_OF_OPTIONS)))
352 {
353 command_print(cmd_ctx, "usage: svf <file> [quiet]");
354 return ERROR_FAIL;
355 }
356
357 // parse variant
358 svf_quiet = 0;
359 for (i = 1; i < argc; i++)
360 {
361 if (!strcmp(args[i], "quiet"))
362 {
363 svf_quiet = 1;
364 }
365 else
366 {
367 LOG_ERROR("unknown variant for svf: %s", args[i]);
368
369 // no need to free anything now
370 return ERROR_FAIL;
371 }
372 }
373
374 if ((svf_fd = open(args[0], O_RDONLY)) < 0)
375 {
376 command_print(cmd_ctx, "file \"%s\" not found", args[0]);
377
378 // no need to free anything now
379 return ERROR_FAIL;
380 }
381
382 LOG_USER("svf processing file: \"%s\"", args[0]);
383
384 // get time
385 time_ago = timeval_ms();
386
387 // init
388 svf_line_number = 1;
389 svf_command_buffer_size = 0;
390
391 svf_check_tdo_para_index = 0;
392 svf_check_tdo_para = malloc(sizeof(svf_check_tdo_para_t) * SVF_CHECK_TDO_PARA_SIZE);
393 if (NULL == svf_check_tdo_para)
394 {
395 LOG_ERROR("not enough memory");
396 ret = ERROR_FAIL;
397 goto free_all;
398 }
399
400 svf_buffer_index = 0;
401 // double the buffer size
402 // in case current command cannot be commited, and next command is a bit scan command
403 // here is 32K bits for this big scan command, it should be enough
404 // buffer will be reallocated if buffer size is not enough
405 svf_tdi_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
406 if (NULL == svf_tdi_buffer)
407 {
408 LOG_ERROR("not enough memory");
409 ret = ERROR_FAIL;
410 goto free_all;
411 }
412 svf_tdo_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
413 if (NULL == svf_tdo_buffer)
414 {
415 LOG_ERROR("not enough memory");
416 ret = ERROR_FAIL;
417 goto free_all;
418 }
419 svf_mask_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
420 if (NULL == svf_mask_buffer)
421 {
422 LOG_ERROR("not enough memory");
423 ret = ERROR_FAIL;
424 goto free_all;
425 }
426 svf_buffer_size = 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT;
427
428 memcpy(&svf_para, &svf_para_init, sizeof(svf_para));
429 for (i = 0; i < (int)dimof(svf_tap_state_name); i++)
430 {
431 svf_tap_state_name[i] = (char *)tap_state_svf_name(i);
432 }
433
434 // TAP_RESET
435 jtag_add_tlr();
436
437 while (ERROR_OK == svf_read_command_from_file(svf_fd))
438 {
439 if (ERROR_OK != svf_run_command(cmd_ctx, svf_command_buffer))
440 {
441 LOG_ERROR("fail to run command at line %d", svf_line_number);
442 ret = ERROR_FAIL;
443 break;
444 }
445 command_num++;
446 }
447 if (ERROR_OK != jtag_execute_queue())
448 {
449 ret = ERROR_FAIL;
450 }
451 else if (ERROR_OK != svf_check_tdo())
452 {
453 ret = ERROR_FAIL;
454 }
455
456 // print time
457 command_print(cmd_ctx, "%lld ms used", timeval_ms() - time_ago);
458
459 free_all:
460
461 close(svf_fd);
462 svf_fd = 0;
463
464 // free buffers
465 if (svf_command_buffer)
466 {
467 free(svf_command_buffer);
468 svf_command_buffer = NULL;
469 svf_command_buffer_size = 0;
470 }
471 if (svf_check_tdo_para)
472 {
473 free(svf_check_tdo_para);
474 svf_check_tdo_para = NULL;
475 svf_check_tdo_para_index = 0;
476 }
477 if (svf_tdi_buffer)
478 {
479 free(svf_tdi_buffer);
480 svf_tdi_buffer = NULL;
481 }
482 if (svf_tdo_buffer)
483 {
484 free(svf_tdo_buffer);
485 svf_tdo_buffer = NULL;
486 }
487 if (svf_mask_buffer)
488 {
489 free(svf_mask_buffer);
490 svf_mask_buffer = NULL;
491 }
492 svf_buffer_index = 0;
493 svf_buffer_size = 0;
494
495 svf_free_xxd_para(&svf_para.hdr_para);
496 svf_free_xxd_para(&svf_para.hir_para);
497 svf_free_xxd_para(&svf_para.tdr_para);
498 svf_free_xxd_para(&svf_para.tir_para);
499 svf_free_xxd_para(&svf_para.sdr_para);
500 svf_free_xxd_para(&svf_para.sir_para);
501
502 if (ERROR_OK == ret)
503 {
504 command_print(cmd_ctx, "svf file programmed successfully for %d commands", command_num);
505 }
506 else
507 {
508 command_print(cmd_ctx, "svf file programmed failed");
509 }
510
511 return ret;
512 }
513
514 #define SVFP_CMD_INC_CNT 1024
515 static int svf_read_command_from_file(int fd)
516 {
517 char ch, *tmp_buffer = NULL;
518 int cmd_pos = 0, cmd_ok = 0, slash = 0, comment = 0;
519
520 while (!cmd_ok && (read(fd, &ch, 1) > 0))
521 {
522 switch (ch)
523 {
524 case '!':
525 slash = 0;
526 comment = 1;
527 break;
528 case '/':
529 if (++slash == 2)
530 {
531 comment = 1;
532 }
533 break;
534 case ';':
535 slash = 0;
536 if (!comment)
537 {
538 cmd_ok = 1;
539 }
540 break;
541 case '\n':
542 svf_line_number++;
543 case '\r':
544 slash = 0;
545 comment = 0;
546 break;
547 default:
548 if (!comment)
549 {
550 if (cmd_pos >= svf_command_buffer_size - 1)
551 {
552 tmp_buffer = (char*)malloc(svf_command_buffer_size + SVFP_CMD_INC_CNT); // 1 more byte for '\0'
553 if (NULL == tmp_buffer)
554 {
555 LOG_ERROR("not enough memory");
556 return ERROR_FAIL;
557 }
558 if (svf_command_buffer_size > 0)
559 {
560 memcpy(tmp_buffer, svf_command_buffer, svf_command_buffer_size);
561 }
562 if (svf_command_buffer != NULL)
563 {
564 free(svf_command_buffer);
565 }
566 svf_command_buffer = tmp_buffer;
567 svf_command_buffer_size += SVFP_CMD_INC_CNT;
568 tmp_buffer = NULL;
569 }
570 svf_command_buffer[cmd_pos++] = (char)toupper(ch);
571 }
572 break;
573 }
574 }
575
576 if (cmd_ok)
577 {
578 svf_command_buffer[cmd_pos] = '\0';
579 return ERROR_OK;
580 }
581 else
582 {
583 return ERROR_FAIL;
584 }
585 }
586
587 static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_argu)
588 {
589 int pos = 0, num = 0, space_found = 1;
590
591 while (pos < len)
592 {
593 switch (str[pos])
594 {
595 case '\n':
596 case '\r':
597 case '!':
598 case '/':
599 LOG_ERROR("fail to parse svf command");
600 return ERROR_FAIL;
601 break;
602 case ' ':
603 space_found = 1;
604 str[pos] = '\0';
605 break;
606 default:
607 if (space_found)
608 {
609 argus[num++] = &str[pos];
610 space_found = 0;
611 }
612 break;
613 }
614 pos++;
615 }
616
617 *num_of_argu = num;
618
619 return ERROR_OK;
620 }
621
622 static int svf_tap_state_is_stable(tap_state_t state)
623 {
624 return ((TAP_RESET == state) || (TAP_IDLE == state) || (TAP_DRPAUSE == state) || (TAP_IRPAUSE == state));
625 }
626
627 static int svf_tap_state_is_valid(tap_state_t state)
628 {
629 return state >= 0 && state < TAP_NUM_STATES;
630 }
631
632 static int svf_find_string_in_array(char *str, char **strs, int num_of_element)
633 {
634 int i;
635
636 for (i = 0; i < num_of_element; i++)
637 {
638 if (!strcmp(str, strs[i]))
639 {
640 return i;
641 }
642 }
643 return 0xFF;
644 }
645
646 static int svf_adjust_array_length(uint8_t **arr, int orig_bit_len, int new_bit_len)
647 {
648 int new_byte_len = (new_bit_len + 7) >> 3;
649
650 if ((NULL == *arr) || (((orig_bit_len + 7) >> 3) < ((new_bit_len + 7) >> 3)))
651 {
652 if (*arr != NULL)
653 {
654 free(*arr);
655 *arr = NULL;
656 }
657 *arr = (uint8_t*)malloc(new_byte_len);
658 if (NULL == *arr)
659 {
660 LOG_ERROR("not enough memory");
661 return ERROR_FAIL;
662 }
663 memset(*arr, 0, new_byte_len);
664 }
665 return ERROR_OK;
666 }
667
668 static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_len, int bit_len)
669 {
670 int i, str_len = strlen(str), str_hbyte_len = (bit_len + 3) >> 2;
671 uint8_t ch = 0;
672
673 if (ERROR_OK != svf_adjust_array_length(bin, orig_bit_len, bit_len))
674 {
675 LOG_ERROR("fail to adjust length of array");
676 return ERROR_FAIL;
677 }
678
679 for (i = 0; i < str_hbyte_len; i++)
680 {
681 ch = 0;
682 while (str_len > 0)
683 {
684 ch = str[--str_len];
685
686 if (!isblank(ch))
687 {
688 if ((ch >= '0') && (ch <= '9'))
689 {
690 ch = ch - '0';
691 break;
692 }
693 else if ((ch >= 'A') && (ch <= 'F'))
694 {
695 ch = ch - 'A' + 10;
696 break;
697 }
698 else
699 {
700 LOG_ERROR("invalid hex string");
701 return ERROR_FAIL;
702 }
703 }
704
705 ch = 0;
706 }
707
708 // write bin
709 if (i % 2)
710 {
711 // MSB
712 (*bin)[i / 2] |= ch << 4;
713 }
714 else
715 {
716 // LSB
717 (*bin)[i / 2] = 0;
718 (*bin)[i / 2] |= ch;
719 }
720 }
721
722 // check valid
723 if (str_len > 0 || (ch & ~((1 << (4 - (bit_len % 4))) - 1)) != 0)
724 {
725 LOG_ERROR("value execede length");
726 return ERROR_FAIL;
727 }
728
729 return ERROR_OK;
730 }
731
732 static int svf_check_tdo(void)
733 {
734 int i, len, index;
735
736 for (i = 0; i < svf_check_tdo_para_index; i++)
737 {
738 index = svf_check_tdo_para[i].buffer_offset;
739 len = svf_check_tdo_para[i].bit_len;
740 if ((svf_check_tdo_para[i].enabled)
741 && buf_cmp_mask(&svf_tdi_buffer[index], &svf_tdo_buffer[index], &svf_mask_buffer[index], len))
742 {
743 unsigned bitmask;
744 unsigned received, expected, tapmask;
745 bitmask = svf_get_mask_u32(svf_check_tdo_para[i].bit_len);
746
747 memcpy(&received, svf_tdi_buffer + index, sizeof(unsigned));
748 memcpy(&expected, svf_tdo_buffer + index, sizeof(unsigned));
749 memcpy(&tapmask, svf_mask_buffer + index, sizeof(unsigned));
750 LOG_ERROR("tdo check error at line %d",
751 svf_check_tdo_para[i].line_num);
752 LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
753 received & bitmask,
754 expected & bitmask,
755 tapmask & bitmask);
756 return ERROR_FAIL;
757 }
758 }
759 svf_check_tdo_para_index = 0;
760
761 return ERROR_OK;
762 }
763
764 static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len)
765 {
766 if (svf_check_tdo_para_index >= SVF_CHECK_TDO_PARA_SIZE)
767 {
768 LOG_ERROR("toooooo many operation undone");
769 return ERROR_FAIL;
770 }
771
772 svf_check_tdo_para[svf_check_tdo_para_index].line_num = svf_line_number;
773 svf_check_tdo_para[svf_check_tdo_para_index].bit_len = bit_len;
774 svf_check_tdo_para[svf_check_tdo_para_index].enabled = enabled;
775 svf_check_tdo_para[svf_check_tdo_para_index].buffer_offset = buffer_offset;
776 svf_check_tdo_para_index++;
777
778 return ERROR_OK;
779 }
780
781 static int svf_execute_tap(void)
782 {
783 if (ERROR_OK != jtag_execute_queue())
784 {
785 return ERROR_FAIL;
786 }
787 else if (ERROR_OK != svf_check_tdo())
788 {
789 return ERROR_FAIL;
790 }
791
792 svf_buffer_index = 0;
793
794 return ERROR_OK;
795 }
796
797 static int svf_run_command(struct command_context_s *cmd_ctx, char *cmd_str)
798 {
799 char *argus[256], command;
800 int num_of_argu = 0, i;
801
802 // tmp variable
803 int i_tmp;
804
805 // for RUNTEST
806 int run_count;
807 float min_time, max_time;
808 // for XXR
809 svf_xxr_para_t *xxr_para_tmp;
810 uint8_t **pbuffer_tmp;
811 scan_field_t field;
812 // for STATE
813 tap_state_t *path = NULL, state;
814
815 if (!svf_quiet)
816 {
817 LOG_USER("%s", svf_command_buffer);
818 }
819
820 if (ERROR_OK != svf_parse_cmd_string(cmd_str, strlen(cmd_str), argus, &num_of_argu))
821 {
822 return ERROR_FAIL;
823 }
824
825 command = svf_find_string_in_array(argus[0], (char **)svf_command_name, dimof(svf_command_name));
826 switch (command)
827 {
828 case ENDDR:
829 case ENDIR:
830 if (num_of_argu != 2)
831 {
832 LOG_ERROR("invalid parameter of %s", argus[0]);
833 return ERROR_FAIL;
834 }
835 i_tmp = svf_find_string_in_array(argus[1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
836 if (svf_tap_state_is_stable(i_tmp))
837 {
838 if (command == ENDIR)
839 {
840 svf_para.ir_end_state = i_tmp;
841 LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name[svf_para.ir_end_state]);
842 }
843 else
844 {
845 svf_para.dr_end_state = i_tmp;
846 LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name[svf_para.dr_end_state]);
847 }
848 }
849 else
850 {
851 LOG_ERROR("%s is not valid state", argus[1]);
852 return ERROR_FAIL;
853 }
854 break;
855 case FREQUENCY:
856 if ((num_of_argu != 1) && (num_of_argu != 3))
857 {
858 LOG_ERROR("invalid parameter of %s", argus[0]);
859 return ERROR_FAIL;
860 }
861 if (1 == num_of_argu)
862 {
863 // TODO: set jtag speed to full speed
864 svf_para.frequency = 0;
865 }
866 else
867 {
868 if (strcmp(argus[2], "HZ"))
869 {
870 LOG_ERROR("HZ not found in FREQUENCY command");
871 return ERROR_FAIL;
872 }
873 if (ERROR_OK != svf_execute_tap())
874 {
875 return ERROR_FAIL;
876 }
877 svf_para.frequency = atof(argus[1]);
878 // TODO: set jtag speed to
879 if (svf_para.frequency > 0)
880 {
881 command_run_linef(cmd_ctx, "jtag_khz %d", (int)svf_para.frequency / 1000);
882 LOG_DEBUG("\tfrequency = %f", svf_para.frequency);
883 }
884 }
885 break;
886 case HDR:
887 xxr_para_tmp = &svf_para.hdr_para;
888 goto XXR_common;
889 case HIR:
890 xxr_para_tmp = &svf_para.hir_para;
891 goto XXR_common;
892 case TDR:
893 xxr_para_tmp = &svf_para.tdr_para;
894 goto XXR_common;
895 case TIR:
896 xxr_para_tmp = &svf_para.tir_para;
897 goto XXR_common;
898 case SDR:
899 xxr_para_tmp = &svf_para.sdr_para;
900 goto XXR_common;
901 case SIR:
902 xxr_para_tmp = &svf_para.sir_para;
903 goto XXR_common;
904 XXR_common:
905 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
906 if ((num_of_argu > 10) || (num_of_argu % 2))
907 {
908 LOG_ERROR("invalid parameter of %s", argus[0]);
909 return ERROR_FAIL;
910 }
911 i_tmp = xxr_para_tmp->len;
912 xxr_para_tmp->len = atoi(argus[1]);
913 LOG_DEBUG("\tlength = %d", xxr_para_tmp->len);
914 xxr_para_tmp->data_mask = 0;
915 for (i = 2; i < num_of_argu; i += 2)
916 {
917 if ((strlen(argus[i + 1]) < 3) || (argus[i + 1][0] != '(') || (argus[i + 1][strlen(argus[i + 1]) - 1] != ')'))
918 {
919 LOG_ERROR("data section error");
920 return ERROR_FAIL;
921 }
922 argus[i + 1][strlen(argus[i + 1]) - 1] = '\0';
923 // TDI, TDO, MASK, SMASK
924 if (!strcmp(argus[i], "TDI"))
925 {
926 // TDI
927 pbuffer_tmp = &xxr_para_tmp->tdi;
928 xxr_para_tmp->data_mask |= XXR_TDI;
929 }
930 else if (!strcmp(argus[i], "TDO"))
931 {
932 // TDO
933 pbuffer_tmp = &xxr_para_tmp->tdo;
934 xxr_para_tmp->data_mask |= XXR_TDO;
935 }
936 else if (!strcmp(argus[i], "MASK"))
937 {
938 // MASK
939 pbuffer_tmp = &xxr_para_tmp->mask;
940 xxr_para_tmp->data_mask |= XXR_MASK;
941 }
942 else if (!strcmp(argus[i], "SMASK"))
943 {
944 // SMASK
945 pbuffer_tmp = &xxr_para_tmp->smask;
946 xxr_para_tmp->data_mask |= XXR_SMASK;
947 }
948 else
949 {
950 LOG_ERROR("unknow parameter: %s", argus[i]);
951 return ERROR_FAIL;
952 }
953 if (ERROR_OK != svf_copy_hexstring_to_binary(&argus[i + 1][1], pbuffer_tmp, i_tmp, xxr_para_tmp->len))
954 {
955 LOG_ERROR("fail to parse hex value");
956 return ERROR_FAIL;
957 }
958 LOG_DEBUG("\t%s = 0x%X", argus[i], (**(int**)pbuffer_tmp) & svf_get_mask_u32(xxr_para_tmp->len));
959 }
960 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
961 // the mask pattern used is all cares
962 if (!(xxr_para_tmp->data_mask & XXR_MASK) && (i_tmp != xxr_para_tmp->len))
963 {
964 // MASK not defined and length changed
965 if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len))
966 {
967 LOG_ERROR("fail to adjust length of array");
968 return ERROR_FAIL;
969 }
970 buf_set_ones(xxr_para_tmp->mask, xxr_para_tmp->len);
971 }
972 // If TDO is absent, no comparison is needed, set the mask to 0
973 if (!(xxr_para_tmp->data_mask & XXR_TDO))
974 {
975 if (NULL == xxr_para_tmp->tdo)
976 {
977 if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->tdo, i_tmp, xxr_para_tmp->len))
978 {
979 LOG_ERROR("fail to adjust length of array");
980 return ERROR_FAIL;
981 }
982 }
983 if (NULL == xxr_para_tmp->mask)
984 {
985 if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len))
986 {
987 LOG_ERROR("fail to adjust length of array");
988 return ERROR_FAIL;
989 }
990 }
991 memset(xxr_para_tmp->mask, 0, (xxr_para_tmp->len + 7) >> 3);
992 }
993 // do scan if necessary
994 if (SDR == command)
995 {
996 // check buffer size first, reallocate if necessary
997 i = svf_para.hdr_para.len + svf_para.sdr_para.len + svf_para.tdr_para.len;
998 if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3))
999 {
1000 #if 1
1001 // simply print error message
1002 LOG_ERROR("buffer is not enough, report to author");
1003 return ERROR_FAIL;
1004 #else
1005 uint8_t *buffer_tmp;
1006
1007 // reallocate buffer
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_tdi_buffer, svf_buffer_index);
1015 // svf_tdi_buffer isn't NULL here
1016 free(svf_tdi_buffer);
1017 svf_tdi_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_tdo_buffer, svf_buffer_index);
1026 // svf_tdo_buffer isn't NULL here
1027 free(svf_tdo_buffer);
1028 svf_tdo_buffer = buffer_tmp;
1029
1030 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1031 if (NULL == buffer_tmp)
1032 {
1033 LOG_ERROR("not enough memory");
1034 return ERROR_FAIL;
1035 }
1036 memcpy(buffer_tmp, svf_mask_buffer, svf_buffer_index);
1037 // svf_mask_buffer isn't NULL here
1038 free(svf_mask_buffer);
1039 svf_mask_buffer = buffer_tmp;
1040
1041 buffer_tmp = NULL;
1042 svf_buffer_size = svf_buffer_index + ((i + 7) >> 3);
1043 #endif
1044 }
1045
1046 // assemble dr data
1047 i = 0;
1048 buf_set_buf(svf_para.hdr_para.tdi, 0, &svf_tdi_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.tdi, 0, &svf_tdi_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.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.tdr_para.len);
1053 i += svf_para.tdr_para.len;
1054
1055 // add check data
1056 if (svf_para.sdr_para.data_mask & XXR_TDO)
1057 {
1058 // assemble dr mask data
1059 i = 0;
1060 buf_set_buf(svf_para.hdr_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.hdr_para.len);
1061 i += svf_para.hdr_para.len;
1062 buf_set_buf(svf_para.sdr_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.sdr_para.len);
1063 i += svf_para.sdr_para.len;
1064 buf_set_buf(svf_para.tdr_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.tdr_para.len);
1065 i += svf_para.tdr_para.len;
1066 // assemble dr check data
1067 i = 0;
1068 buf_set_buf(svf_para.hdr_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.hdr_para.len);
1069 i += svf_para.hdr_para.len;
1070 buf_set_buf(svf_para.sdr_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.sdr_para.len);
1071 i += svf_para.sdr_para.len;
1072 buf_set_buf(svf_para.tdr_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.tdr_para.len);
1073 i += svf_para.tdr_para.len;
1074
1075 svf_add_check_para(1, svf_buffer_index, i);
1076 }
1077 else
1078 {
1079 svf_add_check_para(0, svf_buffer_index, i);
1080 }
1081 field.tap = tap;
1082 field.num_bits = i;
1083 field.out_value = &svf_tdi_buffer[svf_buffer_index];
1084 field.in_value = &svf_tdi_buffer[svf_buffer_index];
1085 jtag_add_plain_dr_scan(1, &field, svf_para.dr_end_state);
1086
1087 svf_buffer_index += (i + 7) >> 3;
1088 }
1089 else if (SIR == command)
1090 {
1091 // check buffer size first, reallocate if necessary
1092 i = svf_para.hir_para.len + svf_para.sir_para.len + svf_para.tir_para.len;
1093 if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3))
1094 {
1095 #if 1
1096 // simply print error message
1097 LOG_ERROR("buffer is not enough, report to author");
1098 return ERROR_FAIL;
1099 #else
1100 uint8_t *buffer_tmp;
1101
1102 // reallocate buffer
1103 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1104 if (NULL == buffer_tmp)
1105 {
1106 LOG_ERROR("not enough memory");
1107 return ERROR_FAIL;
1108 }
1109 memcpy(buffer_tmp, svf_tdi_buffer, svf_buffer_index);
1110 // svf_tdi_buffer isn't NULL here
1111 free(svf_tdi_buffer);
1112 svf_tdi_buffer = buffer_tmp;
1113
1114 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1115 if (NULL == buffer_tmp)
1116 {
1117 LOG_ERROR("not enough memory");
1118 return ERROR_FAIL;
1119 }
1120 memcpy(buffer_tmp, svf_tdo_buffer, svf_buffer_index);
1121 // svf_tdo_buffer isn't NULL here
1122 free(svf_tdo_buffer);
1123 svf_tdo_buffer = buffer_tmp;
1124
1125 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1126 if (NULL == buffer_tmp)
1127 {
1128 LOG_ERROR("not enough memory");
1129 return ERROR_FAIL;
1130 }
1131 memcpy(buffer_tmp, svf_mask_buffer, svf_buffer_index);
1132 // svf_mask_buffer isn't NULL here
1133 free(svf_mask_buffer);
1134 svf_mask_buffer = buffer_tmp;
1135
1136 buffer_tmp = NULL;
1137 svf_buffer_size = svf_buffer_index + ((i + 7) >> 3);
1138 #endif
1139 }
1140
1141 // assemble ir data
1142 i = 0;
1143 buf_set_buf(svf_para.hir_para.tdi, 0, &svf_tdi_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.tdi, 0, &svf_tdi_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.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.tir_para.len);
1148 i += svf_para.tir_para.len;
1149
1150 // add check data
1151 if (svf_para.sir_para.data_mask & XXR_TDO)
1152 {
1153 // assemble dr mask data
1154 i = 0;
1155 buf_set_buf(svf_para.hir_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.hir_para.len);
1156 i += svf_para.hir_para.len;
1157 buf_set_buf(svf_para.sir_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.sir_para.len);
1158 i += svf_para.sir_para.len;
1159 buf_set_buf(svf_para.tir_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.tir_para.len);
1160 i += svf_para.tir_para.len;
1161 // assemble dr check data
1162 i = 0;
1163 buf_set_buf(svf_para.hir_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.hir_para.len);
1164 i += svf_para.hir_para.len;
1165 buf_set_buf(svf_para.sir_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.sir_para.len);
1166 i += svf_para.sir_para.len;
1167 buf_set_buf(svf_para.tir_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.tir_para.len);
1168 i += svf_para.tir_para.len;
1169
1170 svf_add_check_para(1, svf_buffer_index, i);
1171 }
1172 else
1173 {
1174 svf_add_check_para(0, svf_buffer_index, i);
1175 }
1176 field.tap = tap;
1177 field.num_bits = i;
1178 field.out_value = &svf_tdi_buffer[svf_buffer_index];
1179 field.in_value = &svf_tdi_buffer[svf_buffer_index];
1180 jtag_add_plain_ir_scan(1, &field, svf_para.ir_end_state);
1181
1182 svf_buffer_index += (i + 7) >> 3;
1183 }
1184 break;
1185 case PIO:
1186 case PIOMAP:
1187 LOG_ERROR("PIO and PIOMAP are not supported");
1188 return ERROR_FAIL;
1189 break;
1190 case RUNTEST:
1191 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1192 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1193 if ((num_of_argu < 3) && (num_of_argu > 11))
1194 {
1195 LOG_ERROR("invalid parameter of %s", argus[0]);
1196 return ERROR_FAIL;
1197 }
1198 // init
1199 run_count = 0;
1200 min_time = 0;
1201 max_time = 0;
1202 i = 1;
1203 // run_state
1204 i_tmp = svf_find_string_in_array(argus[i], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1205 if (svf_tap_state_is_valid(i_tmp))
1206 {
1207 if (svf_tap_state_is_stable(i_tmp))
1208 {
1209 svf_para.runtest_run_state = i_tmp;
1210
1211 // When a run_state is specified, the new run_state becomes the default end_state
1212 svf_para.runtest_end_state = i_tmp;
1213 LOG_DEBUG("\trun_state = %s", svf_tap_state_name[svf_para.runtest_run_state]);
1214 i++;
1215 }
1216 else
1217 {
1218 LOG_ERROR("%s is not valid state", svf_tap_state_name[i_tmp]);
1219 return ERROR_FAIL;
1220 }
1221 }
1222 // run_count run_clk
1223 if (((i + 2) <= num_of_argu) && strcmp(argus[i + 1], "SEC"))
1224 {
1225 if (!strcmp(argus[i + 1], "TCK"))
1226 {
1227 // clock source is TCK
1228 run_count = atoi(argus[i]);
1229 LOG_DEBUG("\trun_count@TCK = %d", run_count);
1230 }
1231 else
1232 {
1233 LOG_ERROR("%s not supported for clock", argus[i + 1]);
1234 return ERROR_FAIL;
1235 }
1236 i += 2;
1237 }
1238 // min_time SEC
1239 if (((i + 2) <= num_of_argu) && !strcmp(argus[i + 1], "SEC"))
1240 {
1241 min_time = atof(argus[i]);
1242 LOG_DEBUG("\tmin_time = %fs", min_time);
1243 i += 2;
1244 }
1245 // MAXIMUM max_time SEC
1246 if (((i + 3) <= num_of_argu) && !strcmp(argus[i], "MAXIMUM") && !strcmp(argus[i + 2], "SEC"))
1247 {
1248 max_time = atof(argus[i + 1]);
1249 LOG_DEBUG("\tmax_time = %fs", max_time);
1250 i += 3;
1251 }
1252 // ENDSTATE end_state
1253 if (((i + 2) <= num_of_argu) && !strcmp(argus[i], "ENDSTATE"))
1254 {
1255 i_tmp = svf_find_string_in_array(argus[i + 1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1256 if (svf_tap_state_is_stable(i_tmp))
1257 {
1258 svf_para.runtest_end_state = i_tmp;
1259 LOG_DEBUG("\tend_state = %s", svf_tap_state_name[svf_para.runtest_end_state]);
1260 }
1261 else
1262 {
1263 LOG_ERROR("%s is not valid state", svf_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 // enter into run_state if necessary
1282 if (cmd_queue_cur_state != svf_para.runtest_run_state)
1283 {
1284 svf_add_statemove(svf_para.runtest_run_state);
1285 }
1286
1287 // call jtag_add_clocks
1288 jtag_add_clocks(run_count);
1289
1290 // move to end_state if necessary
1291 if (svf_para.runtest_end_state != svf_para.runtest_run_state)
1292 {
1293 svf_add_statemove(svf_para.runtest_end_state);
1294 }
1295 #else
1296 if (svf_para.runtest_run_state != TAP_IDLE)
1297 {
1298 // RUNTEST can only executed in TAP_IDLE
1299 LOG_ERROR("cannot runtest in %s state", svf_tap_state_name[svf_para.runtest_run_state]);
1300 return ERROR_FAIL;
1301 }
1302
1303 jtag_add_runtest(run_count, svf_para.runtest_end_state);
1304 #endif
1305 }
1306 }
1307 else
1308 {
1309 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i, num_of_argu);
1310 return ERROR_FAIL;
1311 }
1312 break;
1313 case STATE:
1314 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1315 if (num_of_argu < 2)
1316 {
1317 LOG_ERROR("invalid parameter of %s", argus[0]);
1318 return ERROR_FAIL;
1319 }
1320 if (num_of_argu > 2)
1321 {
1322 // STATE pathstate1 ... stable_state
1323 path = (tap_state_t *)malloc((num_of_argu - 1) * sizeof(tap_state_t));
1324 if (NULL == path)
1325 {
1326 LOG_ERROR("not enough memory");
1327 return ERROR_FAIL;
1328 }
1329 num_of_argu--; // num of path
1330 i_tmp = 1; // path is from patameter 1
1331 for (i = 0; i < num_of_argu; i++)
1332 {
1333 path[i] = svf_find_string_in_array(argus[i_tmp++], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1334 if (!svf_tap_state_is_valid(path[i]))
1335 {
1336 LOG_ERROR("%s is not valid state", svf_tap_state_name[path[i]]);
1337 free(path);
1338 return ERROR_FAIL;
1339 }
1340 if (TAP_RESET == path[i])
1341 {
1342 if (i > 0)
1343 {
1344 jtag_add_pathmove(i, path);
1345 }
1346 jtag_add_tlr();
1347 num_of_argu -= i + 1;
1348 i = -1;
1349 }
1350 }
1351 if (num_of_argu > 0)
1352 {
1353 // execute last path if necessary
1354 if (svf_tap_state_is_stable(path[num_of_argu - 1]))
1355 {
1356 // last state MUST be stable state
1357 // TODO: call path_move
1358 jtag_add_pathmove(num_of_argu, path);
1359 LOG_DEBUG("\tmove to %s by path_move", svf_tap_state_name[path[num_of_argu - 1]]);
1360 }
1361 else
1362 {
1363 LOG_ERROR("%s is not valid state", svf_tap_state_name[path[num_of_argu - 1]]);
1364 free(path);
1365 return ERROR_FAIL;
1366 }
1367 }
1368 // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1369 if (NULL != path)
1370 {
1371 free(path);
1372 path = NULL;
1373 }
1374 }
1375 else
1376 {
1377 // STATE stable_state
1378 state = svf_find_string_in_array(argus[1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1379 if (svf_tap_state_is_stable(state))
1380 {
1381 // TODO: move to state
1382 svf_add_statemove(state);
1383
1384 LOG_DEBUG("\tmove to %s by svf_add_statemove", svf_tap_state_name[state]);
1385 }
1386 else
1387 {
1388 LOG_ERROR("%s is not valid state", svf_tap_state_name[state]);
1389 return ERROR_FAIL;
1390 }
1391 }
1392 break;
1393 case TRST:
1394 // TRST trst_mode
1395 if (num_of_argu != 2)
1396 {
1397 LOG_ERROR("invalid parameter of %s", argus[0]);
1398 return ERROR_FAIL;
1399 }
1400 if (svf_para.trst_mode != TRST_ABSENT)
1401 {
1402 if (ERROR_OK != svf_execute_tap())
1403 {
1404 return ERROR_FAIL;
1405 }
1406 i_tmp = svf_find_string_in_array(argus[1], (char **)svf_trst_mode_name, dimof(svf_trst_mode_name));
1407 switch (i_tmp)
1408 {
1409 case TRST_ON:
1410 jtag_add_reset(1, 0);
1411 break;
1412 case TRST_Z:
1413 case TRST_OFF:
1414 jtag_add_reset(0, 0);
1415 break;
1416 case TRST_ABSENT:
1417 break;
1418 default:
1419 LOG_ERROR("unknown TRST mode: %s", argus[1]);
1420 return ERROR_FAIL;
1421 }
1422 svf_para.trst_mode = i_tmp;
1423 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name[svf_para.trst_mode]);
1424 }
1425 else
1426 {
1427 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1428 return ERROR_FAIL;
1429 }
1430 break;
1431 default:
1432 LOG_ERROR("invalid svf command: %s", argus[0]);
1433 return ERROR_FAIL;
1434 break;
1435 }
1436
1437 if (debug_level >= LOG_LVL_DEBUG)
1438 {
1439 // for convenient debugging, execute tap if possible
1440 if ((svf_buffer_index > 0) && \
1441 (((command != STATE) && (command != RUNTEST)) || \
1442 ((command == STATE) && (num_of_argu == 2))))
1443 {
1444 if (ERROR_OK != svf_execute_tap())
1445 {
1446 return ERROR_FAIL;
1447 }
1448
1449 // output debug info
1450 if ((SIR == command) || (SDR == command))
1451 {
1452 int read_value;
1453 memcpy(&read_value, svf_tdi_buffer, sizeof(int));
1454 // in debug mode, data is from index 0
1455 int read_mask = svf_get_mask_u32(svf_check_tdo_para[0].bit_len);
1456 LOG_DEBUG("\tTDO read = 0x%X", read_value & read_mask);
1457 }
1458 }
1459 }
1460 else
1461 {
1462 // for fast executing, execute tap if necessary
1463 // half of the buffer is for the next command
1464 if (((svf_buffer_index >= SVF_MAX_BUFFER_SIZE_TO_COMMIT) || (svf_check_tdo_para_index >= SVF_CHECK_TDO_PARA_SIZE / 2)) && \
1465 (((command != STATE) && (command != RUNTEST)) || \
1466 ((command == STATE) && (num_of_argu == 2))))
1467 {
1468 return svf_execute_tap();
1469 }
1470 }
1471
1472 return ERROR_OK;
1473 }
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)