Code Review / openocd.git / blob
? search:


05fb21d631ee13837c4091afa940227a831bc9fd
[openocd.git] / src / svf / svf.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2
3 /***************************************************************************
4 * Copyright (C) 2009 by Simon Qian *
5 * SimonQian@SimonQian.com *
6 ***************************************************************************/
7
8 /* The specification for SVF is available here:
9 * http://www.asset-intertech.com/support/svf.pdf
10 * Below, this document is referred to as the "SVF spec".
11 *
12 * The specification for XSVF is available here:
13 * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
14 * Below, this document is referred to as the "XSVF spec".
15 */
16
17 #ifdef HAVE_CONFIG_H
18 #include "config.h"
19 #endif
20
21 #include <jtag/jtag.h>
22 #include "svf.h"
23 #include "helper/system.h"
24 #include <helper/time_support.h>
25 #include <stdbool.h>
26
27 /* SVF command */
28 enum svf_command {
29 ENDDR,
30 ENDIR,
31 FREQUENCY,
32 HDR,
33 HIR,
34 PIO,
35 PIOMAP,
36 RUNTEST,
37 SDR,
38 SIR,
39 STATE,
40 TDR,
41 TIR,
42 TRST,
43 };
44
45 static const char *svf_command_name[14] = {
46 "ENDDR",
47 "ENDIR",
48 "FREQUENCY",
49 "HDR",
50 "HIR",
51 "PIO",
52 "PIOMAP",
53 "RUNTEST",
54 "SDR",
55 "SIR",
56 "STATE",
57 "TDR",
58 "TIR",
59 "TRST"
60 };
61
62 enum trst_mode {
63 TRST_ON,
64 TRST_OFF,
65 TRST_Z,
66 TRST_ABSENT
67 };
68
69 static const char *svf_trst_mode_name[4] = {
70 "ON",
71 "OFF",
72 "Z",
73 "ABSENT"
74 };
75
76 struct svf_statemove {
77 tap_state_t from;
78 tap_state_t to;
79 uint32_t num_of_moves;
80 tap_state_t paths[8];
81 };
82
83 /*
84 * These paths are from the SVF specification for the STATE command, to be
85 * used when the STATE command only includes the final state. The first
86 * element of the path is the "from" (current) state, and the last one is
87 * the "to" (target) state.
88 *
89 * All specified paths are the shortest ones in the JTAG spec, and are thus
90 * not (!!) exact matches for the paths used elsewhere in OpenOCD. Note
91 * that PAUSE-to-PAUSE transitions all go through UPDATE and then CAPTURE,
92 * which has specific effects on the various registers; they are not NOPs.
93 *
94 * Paths to RESET are disabled here. As elsewhere in OpenOCD, and in XSVF
95 * and many SVF implementations, we don't want to risk missing that state.
96 * To get to RESET, always we ignore the current state.
97 */
98 static const struct svf_statemove svf_statemoves[] = {
99 /* from to num_of_moves, paths[8] */
100 /* {TAP_RESET, TAP_RESET, 1, {TAP_RESET}}, */
101 {TAP_RESET, TAP_IDLE, 2, {TAP_RESET, TAP_IDLE} },
102 {TAP_RESET, TAP_DRPAUSE, 6, {TAP_RESET, TAP_IDLE, TAP_DRSELECT,
103 TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE} },
104 {TAP_RESET, TAP_IRPAUSE, 7, {TAP_RESET, TAP_IDLE, TAP_DRSELECT,
105 TAP_IRSELECT, TAP_IRCAPTURE,
106 TAP_IREXIT1, TAP_IRPAUSE} },
107
108 /* {TAP_IDLE, TAP_RESET, 4, {TAP_IDLE,
109 * TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}}, */
110 {TAP_IDLE, TAP_IDLE, 1, {TAP_IDLE} },
111 {TAP_IDLE, TAP_DRPAUSE, 5, {TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE,
112 TAP_DREXIT1, TAP_DRPAUSE} },
113 {TAP_IDLE, TAP_IRPAUSE, 6, {TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT,
114 TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE} },
115
116 /* {TAP_DRPAUSE, TAP_RESET, 6, {TAP_DRPAUSE,
117 * TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}}, */
118 {TAP_DRPAUSE, TAP_IDLE, 4, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE,
119 TAP_IDLE} },
120 {TAP_DRPAUSE, TAP_DRPAUSE, 7, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE,
121 TAP_DRSELECT, TAP_DRCAPTURE,
122 TAP_DREXIT1, TAP_DRPAUSE} },
123 {TAP_DRPAUSE, TAP_IRPAUSE, 8, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE,
124 TAP_DRSELECT, TAP_IRSELECT,
125 TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE} },
126
127 /* {TAP_IRPAUSE, TAP_RESET, 6, {TAP_IRPAUSE,
128 * TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}}, */
129 {TAP_IRPAUSE, TAP_IDLE, 4, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE,
130 TAP_IDLE} },
131 {TAP_IRPAUSE, TAP_DRPAUSE, 7, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE,
132 TAP_DRSELECT, TAP_DRCAPTURE,
133 TAP_DREXIT1, TAP_DRPAUSE} },
134 {TAP_IRPAUSE, TAP_IRPAUSE, 8, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE,
135 TAP_DRSELECT, TAP_IRSELECT,
136 TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE} }
137 };
138
139 #define XXR_TDI (1 << 0)
140 #define XXR_TDO (1 << 1)
141 #define XXR_MASK (1 << 2)
142 #define XXR_SMASK (1 << 3)
143
144 #define SVF_MAX_ADDCYCLES 255
145
146 struct svf_xxr_para {
147 int len;
148 int data_mask;
149 uint8_t *tdi;
150 uint8_t *tdo;
151 uint8_t *mask;
152 uint8_t *smask;
153 };
154
155 struct svf_para {
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 enum trst_mode 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 /* frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode */
174 0, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TRST_Z,
175 /* hir_para */
176 /* {len, data_mask, tdi, tdo, mask, smask}, */
177 {0, 0, NULL, NULL, NULL, NULL},
178 /* hdr_para */
179 /* {len, data_mask, tdi, tdo, mask, smask}, */
180 {0, 0, NULL, NULL, NULL, NULL},
181 /* tir_para */
182 /* {len, data_mask, tdi, tdo, mask, smask}, */
183 {0, 0, NULL, NULL, NULL, NULL},
184 /* tdr_para */
185 /* {len, data_mask, tdi, tdo, mask, smask}, */
186 {0, 0, NULL, NULL, NULL, NULL},
187 /* sir_para */
188 /* {len, data_mask, tdi, tdo, mask, smask}, */
189 {0, 0, NULL, NULL, NULL, NULL},
190 /* sdr_para */
191 /* {len, data_mask, tdi, tdo, mask, smask}, */
192 {0, 0, NULL, NULL, NULL, NULL},
193 };
194
195 struct svf_check_tdo_para {
196 int line_num; /* used to record line number of the check operation */
197 /* so more information could be printed */
198 int enabled; /* check is enabled or not */
199 int buffer_offset; /* buffer_offset to buffers */
200 int bit_len; /* bit length to check */
201 };
202
203 #define SVF_CHECK_TDO_PARA_SIZE 1024
204 static struct svf_check_tdo_para *svf_check_tdo_para;
205 static int svf_check_tdo_para_index;
206
207 static int svf_read_command_from_file(FILE *fd);
208 static int svf_check_tdo(void);
209 static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len);
210 static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str);
211 static int svf_execute_tap(void);
212
213 static FILE *svf_fd;
214 static char *svf_read_line;
215 static size_t svf_read_line_size;
216 static char *svf_command_buffer;
217 static size_t svf_command_buffer_size;
218 static int svf_line_number;
219 static int svf_getline(char **lineptr, size_t *n, FILE *stream);
220
221 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (1024 * 1024)
222 static uint8_t *svf_tdi_buffer, *svf_tdo_buffer, *svf_mask_buffer;
223 static int svf_buffer_index, svf_buffer_size;
224 static int svf_quiet;
225 static int svf_nil;
226 static int svf_ignore_error;
227 static bool svf_noreset;
228 static int svf_addcycles;
229
230 /* Targeting particular tap */
231 static int svf_tap_is_specified;
232 static int svf_set_padding(struct svf_xxr_para *para, int len, unsigned char tdi);
233
234 /* Progress Indicator */
235 static int svf_progress_enabled;
236 static long svf_total_lines;
237 static int svf_percentage;
238 static int svf_last_printed_percentage = -1;
239
240 /*
241 * macro is used to print the svf hex buffer at desired debug level
242 * DEBUG, INFO, ERROR, USER
243 */
244 #define SVF_BUF_LOG(_lvl, _buf, _nbits, _desc) \
245 svf_hexbuf_print(LOG_LVL_##_lvl, __FILE__, __LINE__, __func__, _buf, _nbits, _desc)
246
247 static void svf_hexbuf_print(int dbg_lvl, const char *file, unsigned line,
248 const char *function, const uint8_t *buf,
249 int bit_len, const char *desc)
250 {
251 int j, len = 0;
252 int byte_len = DIV_ROUND_UP(bit_len, 8);
253 int msbits = bit_len % 8;
254
255 /* allocate 2 bytes per hex digit */
256 char *prbuf = malloc((byte_len * 2) + 2 + 1);
257 if (!prbuf)
258 return;
259
260 /* print correct number of bytes, mask excess bits where applicable */
261 uint8_t msb = buf[byte_len - 1] & (msbits ? (1 << msbits) - 1 : 0xff);
262 len = sprintf(prbuf, msbits <= 4 ? "0x%01"PRIx8 : "0x%02"PRIx8, msb);
263 for (j = byte_len - 2; j >= 0; j--)
264 len += sprintf(prbuf + len, "%02"PRIx8, buf[j]);
265
266 log_printf_lf(dbg_lvl, file, line, function, "%8s = %s", desc ? desc : " ", prbuf);
267
268 free(prbuf);
269 }
270
271 static int svf_realloc_buffers(size_t len)
272 {
273 void *ptr;
274
275 if (svf_execute_tap() != ERROR_OK)
276 return ERROR_FAIL;
277
278 ptr = realloc(svf_tdi_buffer, len);
279 if (!ptr)
280 return ERROR_FAIL;
281 svf_tdi_buffer = ptr;
282
283 ptr = realloc(svf_tdo_buffer, len);
284 if (!ptr)
285 return ERROR_FAIL;
286 svf_tdo_buffer = ptr;
287
288 ptr = realloc(svf_mask_buffer, len);
289 if (!ptr)
290 return ERROR_FAIL;
291 svf_mask_buffer = ptr;
292
293 svf_buffer_size = len;
294
295 return ERROR_OK;
296 }
297
298 static void svf_free_xxd_para(struct svf_xxr_para *para)
299 {
300 if (para) {
301 free(para->tdi);
302 para->tdi = NULL;
303
304 free(para->tdo);
305 para->tdo = NULL;
306
307 free(para->mask);
308 para->mask = NULL;
309
310 free(para->smask);
311 para->smask = NULL;
312 }
313 }
314
315 int svf_add_statemove(tap_state_t state_to)
316 {
317 tap_state_t state_from = cmd_queue_cur_state;
318 unsigned index_var;
319
320 /* when resetting, be paranoid and ignore current state */
321 if (state_to == TAP_RESET) {
322 if (svf_nil)
323 return ERROR_OK;
324
325 jtag_add_tlr();
326 return ERROR_OK;
327 }
328
329 for (index_var = 0; index_var < ARRAY_SIZE(svf_statemoves); index_var++) {
330 if ((svf_statemoves[index_var].from == state_from)
331 && (svf_statemoves[index_var].to == state_to)) {
332 if (svf_nil)
333 continue;
334 /* recorded path includes current state ... avoid
335 *extra TCKs! */
336 if (svf_statemoves[index_var].num_of_moves > 1)
337 jtag_add_pathmove(svf_statemoves[index_var].num_of_moves - 1,
338 svf_statemoves[index_var].paths + 1);
339 else
340 jtag_add_pathmove(svf_statemoves[index_var].num_of_moves,
341 svf_statemoves[index_var].paths);
342 return ERROR_OK;
343 }
344 }
345 LOG_ERROR("SVF: can not move to %s", tap_state_name(state_to));
346 return ERROR_FAIL;
347 }
348
349 COMMAND_HANDLER(handle_svf_command)
350 {
351 #define SVF_MIN_NUM_OF_OPTIONS 1
352 #define SVF_MAX_NUM_OF_OPTIONS 8
353 int command_num = 0;
354 int ret = ERROR_OK;
355 int64_t time_measure_ms;
356 int time_measure_s, time_measure_m;
357
358 /* use NULL to indicate a "plain" svf file which accounts for
359 * any additional devices in the scan chain, otherwise the device
360 * that should be affected
361 */
362 struct jtag_tap *tap = NULL;
363
364 if ((CMD_ARGC < SVF_MIN_NUM_OF_OPTIONS) || (CMD_ARGC > SVF_MAX_NUM_OF_OPTIONS))
365 return ERROR_COMMAND_SYNTAX_ERROR;
366
367 /* parse command line */
368 svf_quiet = 0;
369 svf_nil = 0;
370 svf_progress_enabled = 0;
371 svf_ignore_error = 0;
372 svf_noreset = false;
373 svf_addcycles = 0;
374
375 for (unsigned int i = 0; i < CMD_ARGC; i++) {
376 if (strcmp(CMD_ARGV[i], "-addcycles") == 0) {
377 svf_addcycles = atoi(CMD_ARGV[i + 1]);
378 if (svf_addcycles > SVF_MAX_ADDCYCLES) {
379 command_print(CMD, "addcycles: %s out of range", CMD_ARGV[i + 1]);
380 if (svf_fd)
381 fclose(svf_fd);
382 svf_fd = NULL;
383 return ERROR_FAIL;
384 }
385 i++;
386 } else if (strcmp(CMD_ARGV[i], "-tap") == 0) {
387 tap = jtag_tap_by_string(CMD_ARGV[i+1]);
388 if (!tap) {
389 command_print(CMD, "Tap: %s unknown", CMD_ARGV[i+1]);
390 if (svf_fd)
391 fclose(svf_fd);
392 svf_fd = NULL;
393 return ERROR_FAIL;
394 }
395 i++;
396 } else if ((strcmp(CMD_ARGV[i],
397 "quiet") == 0) || (strcmp(CMD_ARGV[i], "-quiet") == 0))
398 svf_quiet = 1;
399 else if ((strcmp(CMD_ARGV[i], "nil") == 0) || (strcmp(CMD_ARGV[i], "-nil") == 0))
400 svf_nil = 1;
401 else if ((strcmp(CMD_ARGV[i],
402 "progress") == 0) || (strcmp(CMD_ARGV[i], "-progress") == 0))
403 svf_progress_enabled = 1;
404 else if ((strcmp(CMD_ARGV[i],
405 "ignore_error") == 0) || (strcmp(CMD_ARGV[i], "-ignore_error") == 0))
406 svf_ignore_error = 1;
407 else if (strcmp(CMD_ARGV[i], "-noreset") == 0)
408 svf_noreset = true;
409 else {
410 svf_fd = fopen(CMD_ARGV[i], "r");
411 if (!svf_fd) {
412 int err = errno;
413 command_print(CMD, "open(\"%s\"): %s", CMD_ARGV[i], strerror(err));
414 /* no need to free anything now */
415 return ERROR_COMMAND_SYNTAX_ERROR;
416 } else
417 LOG_USER("svf processing file: \"%s\"", CMD_ARGV[i]);
418 }
419 }
420
421 if (!svf_fd)
422 return ERROR_COMMAND_SYNTAX_ERROR;
423
424 /* get time */
425 time_measure_ms = timeval_ms();
426
427 /* init */
428 svf_line_number = 0;
429 svf_command_buffer_size = 0;
430
431 svf_check_tdo_para_index = 0;
432 svf_check_tdo_para = malloc(sizeof(struct svf_check_tdo_para) * SVF_CHECK_TDO_PARA_SIZE);
433 if (!svf_check_tdo_para) {
434 LOG_ERROR("not enough memory");
435 ret = ERROR_FAIL;
436 goto free_all;
437 }
438
439 svf_buffer_index = 0;
440 /* double the buffer size */
441 /* in case current command cannot be committed, and next command is a bit scan command */
442 /* here is 32K bits for this big scan command, it should be enough */
443 /* buffer will be reallocated if buffer size is not enough */
444 if (svf_realloc_buffers(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT) != ERROR_OK) {
445 ret = ERROR_FAIL;
446 goto free_all;
447 }
448
449 memcpy(&svf_para, &svf_para_init, sizeof(svf_para));
450
451 if (!svf_nil && !svf_noreset) {
452 /* TAP_RESET */
453 jtag_add_tlr();
454 }
455
456 if (tap) {
457 /* Tap is specified, set header/trailer paddings */
458 int header_ir_len = 0, header_dr_len = 0, trailer_ir_len = 0, trailer_dr_len = 0;
459 struct jtag_tap *check_tap;
460
461 svf_tap_is_specified = 1;
462
463 for (check_tap = jtag_all_taps(); check_tap; check_tap = check_tap->next_tap) {
464 if (check_tap->abs_chain_position < tap->abs_chain_position) {
465 /* Header */
466 header_ir_len += check_tap->ir_length;
467 header_dr_len++;
468 } else if (check_tap->abs_chain_position > tap->abs_chain_position) {
469 /* Trailer */
470 trailer_ir_len += check_tap->ir_length;
471 trailer_dr_len++;
472 }
473 }
474
475 /* HDR %d TDI (0) */
476 if (svf_set_padding(&svf_para.hdr_para, header_dr_len, 0) != ERROR_OK) {
477 LOG_ERROR("failed to set data header");
478 return ERROR_FAIL;
479 }
480
481 /* HIR %d TDI (0xFF) */
482 if (svf_set_padding(&svf_para.hir_para, header_ir_len, 0xFF) != ERROR_OK) {
483 LOG_ERROR("failed to set instruction header");
484 return ERROR_FAIL;
485 }
486
487 /* TDR %d TDI (0) */
488 if (svf_set_padding(&svf_para.tdr_para, trailer_dr_len, 0) != ERROR_OK) {
489 LOG_ERROR("failed to set data trailer");
490 return ERROR_FAIL;
491 }
492
493 /* TIR %d TDI (0xFF) */
494 if (svf_set_padding(&svf_para.tir_para, trailer_ir_len, 0xFF) != ERROR_OK) {
495 LOG_ERROR("failed to set instruction trailer");
496 return ERROR_FAIL;
497 }
498 }
499
500 if (svf_progress_enabled) {
501 /* Count total lines in file. */
502 while (!feof(svf_fd)) {
503 svf_getline(&svf_command_buffer, &svf_command_buffer_size, svf_fd);
504 svf_total_lines++;
505 }
506 rewind(svf_fd);
507 }
508 while (svf_read_command_from_file(svf_fd) == ERROR_OK) {
509 /* Log Output */
510 if (svf_quiet) {
511 if (svf_progress_enabled) {
512 svf_percentage = ((svf_line_number * 20) / svf_total_lines) * 5;
513 if (svf_last_printed_percentage != svf_percentage) {
514 LOG_USER_N("\r%d%% ", svf_percentage);
515 svf_last_printed_percentage = svf_percentage;
516 }
517 }
518 } else {
519 if (svf_progress_enabled) {
520 svf_percentage = ((svf_line_number * 20) / svf_total_lines) * 5;
521 LOG_USER_N("%3d%% %s", svf_percentage, svf_read_line);
522 } else
523 LOG_USER_N("%s", svf_read_line);
524 }
525 /* Run Command */
526 if (svf_run_command(CMD_CTX, svf_command_buffer) != ERROR_OK) {
527 LOG_ERROR("fail to run command at line %d", svf_line_number);
528 ret = ERROR_FAIL;
529 break;
530 }
531 command_num++;
532 }
533
534 if ((!svf_nil) && (jtag_execute_queue() != ERROR_OK))
535 ret = ERROR_FAIL;
536 else if (svf_check_tdo() != ERROR_OK)
537 ret = ERROR_FAIL;
538
539 /* print time */
540 time_measure_ms = timeval_ms() - time_measure_ms;
541 time_measure_s = time_measure_ms / 1000;
542 time_measure_ms %= 1000;
543 time_measure_m = time_measure_s / 60;
544 time_measure_s %= 60;
545 if (time_measure_ms < 1000)
546 command_print(CMD,
547 "\r\nTime used: %dm%ds%" PRId64 "ms ",
548 time_measure_m,
549 time_measure_s,
550 time_measure_ms);
551
552 free_all:
553
554 fclose(svf_fd);
555 svf_fd = NULL;
556
557 /* free buffers */
558 free(svf_command_buffer);
559 svf_command_buffer = NULL;
560 svf_command_buffer_size = 0;
561
562 free(svf_check_tdo_para);
563 svf_check_tdo_para = NULL;
564 svf_check_tdo_para_index = 0;
565
566 free(svf_tdi_buffer);
567 svf_tdi_buffer = NULL;
568
569 free(svf_tdo_buffer);
570 svf_tdo_buffer = NULL;
571
572 free(svf_mask_buffer);
573 svf_mask_buffer = NULL;
574
575 svf_buffer_index = 0;
576 svf_buffer_size = 0;
577
578 svf_free_xxd_para(&svf_para.hdr_para);
579 svf_free_xxd_para(&svf_para.hir_para);
580 svf_free_xxd_para(&svf_para.tdr_para);
581 svf_free_xxd_para(&svf_para.tir_para);
582 svf_free_xxd_para(&svf_para.sdr_para);
583 svf_free_xxd_para(&svf_para.sir_para);
584
585 if (ret == ERROR_OK)
586 command_print(CMD,
587 "svf file programmed %s for %d commands with %d errors",
588 (svf_ignore_error > 1) ? "unsuccessfully" : "successfully",
589 command_num,
590 (svf_ignore_error > 1) ? (svf_ignore_error - 1) : 0);
591 else
592 command_print(CMD, "svf file programmed failed");
593
594 svf_ignore_error = 0;
595 return ret;
596 }
597
598 static int svf_getline(char **lineptr, size_t *n, FILE *stream)
599 {
600 #define MIN_CHUNK 16 /* Buffer is increased by this size each time as required */
601 size_t i = 0;
602
603 if (!*lineptr) {
604 *n = MIN_CHUNK;
605 *lineptr = malloc(*n);
606 if (!*lineptr)
607 return -1;
608 }
609
610 (*lineptr)[0] = fgetc(stream);
611 while ((*lineptr)[i] != '\n') {
612 (*lineptr)[++i] = fgetc(stream);
613 if (feof(stream)) {
614 (*lineptr)[0] = 0;
615 return -1;
616 }
617 if ((i + 2) > *n) {
618 *n += MIN_CHUNK;
619 *lineptr = realloc(*lineptr, *n);
620 }
621 }
622
623 (*lineptr)[++i] = 0;
624
625 return sizeof(*lineptr);
626 }
627
628 #define SVFP_CMD_INC_CNT 1024
629 static int svf_read_command_from_file(FILE *fd)
630 {
631 unsigned char ch;
632 int i = 0;
633 size_t cmd_pos = 0;
634 int cmd_ok = 0, slash = 0;
635
636 if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
637 return ERROR_FAIL;
638 svf_line_number++;
639 ch = svf_read_line[0];
640 while (!cmd_ok && (ch != 0)) {
641 switch (ch) {
642 case '!':
643 slash = 0;
644 if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
645 return ERROR_FAIL;
646 svf_line_number++;
647 i = -1;
648 break;
649 case '/':
650 if (++slash == 2) {
651 slash = 0;
652 if (svf_getline(&svf_read_line, &svf_read_line_size,
653 svf_fd) <= 0)
654 return ERROR_FAIL;
655 svf_line_number++;
656 i = -1;
657 }
658 break;
659 case ';':
660 slash = 0;
661 cmd_ok = 1;
662 break;
663 case '\n':
664 svf_line_number++;
665 if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
666 return ERROR_FAIL;
667 i = -1;
668 /* fallthrough */
669 case '\r':
670 slash = 0;
671 /* Don't save '\r' and '\n' if no data is parsed */
672 if (!cmd_pos)
673 break;
674 /* fallthrough */
675 default:
676 /* The parsing code currently expects a space
677 * before parentheses -- "TDI (123)". Also a
678 * space afterwards -- "TDI (123) TDO(456)".
679 * But such spaces are optional... instead of
680 * parser updates, cope with that by adding the
681 * spaces as needed.
682 *
683 * Ensure there are 3 bytes available, for:
684 * - current character
685 * - added space.
686 * - terminating NUL ('\0')
687 */
688 if (cmd_pos + 3 > svf_command_buffer_size) {
689 svf_command_buffer = realloc(svf_command_buffer, cmd_pos + 3);
690 svf_command_buffer_size = cmd_pos + 3;
691 if (!svf_command_buffer) {
692 LOG_ERROR("not enough memory");
693 return ERROR_FAIL;
694 }
695 }
696
697 /* insert a space before '(' */
698 if ('(' == ch)
699 svf_command_buffer[cmd_pos++] = ' ';
700
701 svf_command_buffer[cmd_pos++] = (char)toupper(ch);
702
703 /* insert a space after ')' */
704 if (')' == ch)
705 svf_command_buffer[cmd_pos++] = ' ';
706 break;
707 }
708 ch = svf_read_line[++i];
709 }
710
711 if (cmd_ok) {
712 svf_command_buffer[cmd_pos] = '\0';
713 return ERROR_OK;
714 } else
715 return ERROR_FAIL;
716 }
717
718 static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_argu)
719 {
720 int pos = 0, num = 0, space_found = 1, in_bracket = 0;
721
722 while (pos < len) {
723 switch (str[pos]) {
724 case '!':
725 case '/':
726 LOG_ERROR("fail to parse svf command");
727 return ERROR_FAIL;
728 case '(':
729 in_bracket = 1;
730 goto parse_char;
731 case ')':
732 in_bracket = 0;
733 goto parse_char;
734 default:
735 parse_char:
736 if (!in_bracket && isspace((int) str[pos])) {
737 space_found = 1;
738 str[pos] = '\0';
739 } else if (space_found) {
740 argus[num++] = &str[pos];
741 space_found = 0;
742 }
743 break;
744 }
745 pos++;
746 }
747
748 if (num == 0)
749 return ERROR_FAIL;
750
751 *num_of_argu = num;
752
753 return ERROR_OK;
754 }
755
756 bool svf_tap_state_is_stable(tap_state_t state)
757 {
758 return (state == TAP_RESET) || (state == TAP_IDLE)
759 || (state == TAP_DRPAUSE) || (state == TAP_IRPAUSE);
760 }
761
762 static int svf_find_string_in_array(char *str, char **strs, int num_of_element)
763 {
764 int i;
765
766 for (i = 0; i < num_of_element; i++) {
767 if (!strcmp(str, strs[i]))
768 return i;
769 }
770 return 0xFF;
771 }
772
773 static int svf_adjust_array_length(uint8_t **arr, int orig_bit_len, int new_bit_len)
774 {
775 int new_byte_len = (new_bit_len + 7) >> 3;
776
777 if ((!*arr) || (((orig_bit_len + 7) >> 3) < ((new_bit_len + 7) >> 3))) {
778 free(*arr);
779 *arr = calloc(1, new_byte_len);
780 if (!*arr) {
781 LOG_ERROR("not enough memory");
782 return ERROR_FAIL;
783 }
784 }
785 return ERROR_OK;
786 }
787
788 static int svf_set_padding(struct svf_xxr_para *para, int len, unsigned char tdi)
789 {
790 int error = ERROR_OK;
791 error |= svf_adjust_array_length(&para->tdi, para->len, len);
792 memset(para->tdi, tdi, (len + 7) >> 3);
793 error |= svf_adjust_array_length(&para->tdo, para->len, len);
794 error |= svf_adjust_array_length(&para->mask, para->len, len);
795 para->len = len;
796 para->data_mask = XXR_TDI;
797
798 return error;
799 }
800
801 static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_len, int bit_len)
802 {
803 int i, str_len = strlen(str), str_hbyte_len = (bit_len + 3) >> 2;
804 uint8_t ch = 0;
805
806 if (svf_adjust_array_length(bin, orig_bit_len, bit_len) != ERROR_OK) {
807 LOG_ERROR("fail to adjust length of array");
808 return ERROR_FAIL;
809 }
810
811 /* fill from LSB (end of str) to MSB (beginning of str) */
812 for (i = 0; i < str_hbyte_len; i++) {
813 ch = 0;
814 while (str_len > 0) {
815 ch = str[--str_len];
816
817 /* Skip whitespace. The SVF specification (rev E) is
818 * deficient in terms of basic lexical issues like
819 * where whitespace is allowed. Long bitstrings may
820 * require line ends for correctness, since there is
821 * a hard limit on line length.
822 */
823 if (!isspace(ch)) {
824 if ((ch >= '0') && (ch <= '9')) {
825 ch = ch - '0';
826 break;
827 } else if ((ch >= 'A') && (ch <= 'F')) {
828 ch = ch - 'A' + 10;
829 break;
830 } else {
831 LOG_ERROR("invalid hex string");
832 return ERROR_FAIL;
833 }
834 }
835
836 ch = 0;
837 }
838
839 /* write bin */
840 if (i % 2) {
841 /* MSB */
842 (*bin)[i / 2] |= ch << 4;
843 } else {
844 /* LSB */
845 (*bin)[i / 2] = 0;
846 (*bin)[i / 2] |= ch;
847 }
848 }
849
850 /* consume optional leading '0' MSBs or whitespace */
851 while (str_len > 0 && ((str[str_len - 1] == '0')
852 || isspace((int) str[str_len - 1])))
853 str_len--;
854
855 /* check validity: we must have consumed everything */
856 if (str_len > 0 || (ch & ~((2 << ((bit_len - 1) % 4)) - 1)) != 0) {
857 LOG_ERROR("value exceeds length");
858 return ERROR_FAIL;
859 }
860
861 return ERROR_OK;
862 }
863
864 static int svf_check_tdo(void)
865 {
866 int i, len, index_var;
867
868 for (i = 0; i < svf_check_tdo_para_index; i++) {
869 index_var = svf_check_tdo_para[i].buffer_offset;
870 len = svf_check_tdo_para[i].bit_len;
871 if ((svf_check_tdo_para[i].enabled)
872 && buf_cmp_mask(&svf_tdi_buffer[index_var], &svf_tdo_buffer[index_var],
873 &svf_mask_buffer[index_var], len)) {
874 LOG_ERROR("tdo check error at line %d",
875 svf_check_tdo_para[i].line_num);
876 SVF_BUF_LOG(ERROR, &svf_tdi_buffer[index_var], len, "READ");
877 SVF_BUF_LOG(ERROR, &svf_tdo_buffer[index_var], len, "WANT");
878 SVF_BUF_LOG(ERROR, &svf_mask_buffer[index_var], len, "MASK");
879
880 if (svf_ignore_error == 0)
881 return ERROR_FAIL;
882 else
883 svf_ignore_error++;
884 }
885 }
886 svf_check_tdo_para_index = 0;
887
888 return ERROR_OK;
889 }
890
891 static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len)
892 {
893 if (svf_check_tdo_para_index >= SVF_CHECK_TDO_PARA_SIZE) {
894 LOG_ERROR("toooooo many operation undone");
895 return ERROR_FAIL;
896 }
897
898 svf_check_tdo_para[svf_check_tdo_para_index].line_num = svf_line_number;
899 svf_check_tdo_para[svf_check_tdo_para_index].bit_len = bit_len;
900 svf_check_tdo_para[svf_check_tdo_para_index].enabled = enabled;
901 svf_check_tdo_para[svf_check_tdo_para_index].buffer_offset = buffer_offset;
902 svf_check_tdo_para_index++;
903
904 return ERROR_OK;
905 }
906
907 static int svf_execute_tap(void)
908 {
909 if ((!svf_nil) && (jtag_execute_queue() != ERROR_OK))
910 return ERROR_FAIL;
911 else if (svf_check_tdo() != ERROR_OK)
912 return ERROR_FAIL;
913
914 svf_buffer_index = 0;
915
916 return ERROR_OK;
917 }
918
919 static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
920 {
921 char *argus[256], command;
922 int num_of_argu = 0, i;
923
924 /* tmp variable */
925 int i_tmp;
926
927 /* for RUNTEST */
928 int run_count;
929 float min_time;
930 /* for XXR */
931 struct svf_xxr_para *xxr_para_tmp;
932 uint8_t **pbuffer_tmp;
933 struct scan_field field;
934 /* for STATE */
935 tap_state_t *path = NULL, state;
936 /* flag padding commands skipped due to -tap command */
937 int padding_command_skipped = 0;
938
939 if (svf_parse_cmd_string(cmd_str, strlen(cmd_str), argus, &num_of_argu) != ERROR_OK)
940 return ERROR_FAIL;
941
942 /* NOTE: we're a bit loose here, because we ignore case in
943 * TAP state names (instead of insisting on uppercase).
944 */
945
946 command = svf_find_string_in_array(argus[0],
947 (char **)svf_command_name, ARRAY_SIZE(svf_command_name));
948 switch (command) {
949 case ENDDR:
950 case ENDIR:
951 if (num_of_argu != 2) {
952 LOG_ERROR("invalid parameter of %s", argus[0]);
953 return ERROR_FAIL;
954 }
955
956 i_tmp = tap_state_by_name(argus[1]);
957
958 if (svf_tap_state_is_stable(i_tmp)) {
959 if (command == ENDIR) {
960 svf_para.ir_end_state = i_tmp;
961 LOG_DEBUG("\tIR end_state = %s",
962 tap_state_name(i_tmp));
963 } else {
964 svf_para.dr_end_state = i_tmp;
965 LOG_DEBUG("\tDR end_state = %s",
966 tap_state_name(i_tmp));
967 }
968 } else {
969 LOG_ERROR("%s: %s is not a stable state",
970 argus[0], argus[1]);
971 return ERROR_FAIL;
972 }
973 break;
974 case FREQUENCY:
975 if ((num_of_argu != 1) && (num_of_argu != 3)) {
976 LOG_ERROR("invalid parameter of %s", argus[0]);
977 return ERROR_FAIL;
978 }
979 if (num_of_argu == 1) {
980 /* TODO: set jtag speed to full speed */
981 svf_para.frequency = 0;
982 } else {
983 if (strcmp(argus[2], "HZ")) {
984 LOG_ERROR("HZ not found in FREQUENCY command");
985 return ERROR_FAIL;
986 }
987 if (svf_execute_tap() != ERROR_OK)
988 return ERROR_FAIL;
989 svf_para.frequency = atof(argus[1]);
990 /* TODO: set jtag speed to */
991 if (svf_para.frequency > 0) {
992 command_run_linef(cmd_ctx,
993 "adapter speed %d",
994 (int)svf_para.frequency / 1000);
995 LOG_DEBUG("\tfrequency = %f", svf_para.frequency);
996 }
997 }
998 break;
999 case HDR:
1000 if (svf_tap_is_specified) {
1001 padding_command_skipped = 1;
1002 break;
1003 }
1004 xxr_para_tmp = &svf_para.hdr_para;
1005 goto xxr_common;
1006 case HIR:
1007 if (svf_tap_is_specified) {
1008 padding_command_skipped = 1;
1009 break;
1010 }
1011 xxr_para_tmp = &svf_para.hir_para;
1012 goto xxr_common;
1013 case TDR:
1014 if (svf_tap_is_specified) {
1015 padding_command_skipped = 1;
1016 break;
1017 }
1018 xxr_para_tmp = &svf_para.tdr_para;
1019 goto xxr_common;
1020 case TIR:
1021 if (svf_tap_is_specified) {
1022 padding_command_skipped = 1;
1023 break;
1024 }
1025 xxr_para_tmp = &svf_para.tir_para;
1026 goto xxr_common;
1027 case SDR:
1028 xxr_para_tmp = &svf_para.sdr_para;
1029 goto xxr_common;
1030 case SIR:
1031 xxr_para_tmp = &svf_para.sir_para;
1032 goto xxr_common;
1033 xxr_common:
1034 /* XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)] */
1035 if ((num_of_argu > 10) || (num_of_argu % 2)) {
1036 LOG_ERROR("invalid parameter of %s", argus[0]);
1037 return ERROR_FAIL;
1038 }
1039 i_tmp = xxr_para_tmp->len;
1040 xxr_para_tmp->len = atoi(argus[1]);
1041 /* If we are to enlarge the buffers, all parts of xxr_para_tmp
1042 * need to be freed */
1043 if (i_tmp < xxr_para_tmp->len) {
1044 free(xxr_para_tmp->tdi);
1045 xxr_para_tmp->tdi = NULL;
1046 free(xxr_para_tmp->tdo);
1047 xxr_para_tmp->tdo = NULL;
1048 free(xxr_para_tmp->mask);
1049 xxr_para_tmp->mask = NULL;
1050 free(xxr_para_tmp->smask);
1051 xxr_para_tmp->smask = NULL;
1052 }
1053
1054 LOG_DEBUG("\tlength = %d", xxr_para_tmp->len);
1055 xxr_para_tmp->data_mask = 0;
1056 for (i = 2; i < num_of_argu; i += 2) {
1057 if ((strlen(argus[i + 1]) < 3) || (argus[i + 1][0] != '(') ||
1058 (argus[i + 1][strlen(argus[i + 1]) - 1] != ')')) {
1059 LOG_ERROR("data section error");
1060 return ERROR_FAIL;
1061 }
1062 argus[i + 1][strlen(argus[i + 1]) - 1] = '\0';
1063 /* TDI, TDO, MASK, SMASK */
1064 if (!strcmp(argus[i], "TDI")) {
1065 /* TDI */
1066 pbuffer_tmp = &xxr_para_tmp->tdi;
1067 xxr_para_tmp->data_mask |= XXR_TDI;
1068 } else if (!strcmp(argus[i], "TDO")) {
1069 /* TDO */
1070 pbuffer_tmp = &xxr_para_tmp->tdo;
1071 xxr_para_tmp->data_mask |= XXR_TDO;
1072 } else if (!strcmp(argus[i], "MASK")) {
1073 /* MASK */
1074 pbuffer_tmp = &xxr_para_tmp->mask;
1075 xxr_para_tmp->data_mask |= XXR_MASK;
1076 } else if (!strcmp(argus[i], "SMASK")) {
1077 /* SMASK */
1078 pbuffer_tmp = &xxr_para_tmp->smask;
1079 xxr_para_tmp->data_mask |= XXR_SMASK;
1080 } else {
1081 LOG_ERROR("unknown parameter: %s", argus[i]);
1082 return ERROR_FAIL;
1083 }
1084 if (ERROR_OK !=
1085 svf_copy_hexstring_to_binary(&argus[i + 1][1], pbuffer_tmp, i_tmp,
1086 xxr_para_tmp->len)) {
1087 LOG_ERROR("fail to parse hex value");
1088 return ERROR_FAIL;
1089 }
1090 SVF_BUF_LOG(DEBUG, *pbuffer_tmp, xxr_para_tmp->len, argus[i]);
1091 }
1092 /* If a command changes the length of the last scan of the same type and the
1093 * MASK parameter is absent, */
1094 /* the mask pattern used is all cares */
1095 if (!(xxr_para_tmp->data_mask & XXR_MASK) && (i_tmp != xxr_para_tmp->len)) {
1096 /* MASK not defined and length changed */
1097 if (ERROR_OK !=
1098 svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp,
1099 xxr_para_tmp->len)) {
1100 LOG_ERROR("fail to adjust length of array");
1101 return ERROR_FAIL;
1102 }
1103 buf_set_ones(xxr_para_tmp->mask, xxr_para_tmp->len);
1104 }
1105 /* If TDO is absent, no comparison is needed, set the mask to 0 */
1106 if (!(xxr_para_tmp->data_mask & XXR_TDO)) {
1107 if (!xxr_para_tmp->tdo) {
1108 if (ERROR_OK !=
1109 svf_adjust_array_length(&xxr_para_tmp->tdo, i_tmp,
1110 xxr_para_tmp->len)) {
1111 LOG_ERROR("fail to adjust length of array");
1112 return ERROR_FAIL;
1113 }
1114 }
1115 if (!xxr_para_tmp->mask) {
1116 if (ERROR_OK !=
1117 svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp,
1118 xxr_para_tmp->len)) {
1119 LOG_ERROR("fail to adjust length of array");
1120 return ERROR_FAIL;
1121 }
1122 }
1123 memset(xxr_para_tmp->mask, 0, (xxr_para_tmp->len + 7) >> 3);
1124 }
1125 /* do scan if necessary */
1126 if (command == SDR) {
1127 /* check buffer size first, reallocate if necessary */
1128 i = svf_para.hdr_para.len + svf_para.sdr_para.len +
1129 svf_para.tdr_para.len;
1130 if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3)) {
1131 /* reallocate buffer */
1132 if (svf_realloc_buffers(svf_buffer_index + ((i + 7) >> 3)) != ERROR_OK) {
1133 LOG_ERROR("not enough memory");
1134 return ERROR_FAIL;
1135 }
1136 }
1137
1138 /* assemble dr data */
1139 i = 0;
1140 buf_set_buf(svf_para.hdr_para.tdi,
1141 0,
1142 &svf_tdi_buffer[svf_buffer_index],
1143 i,
1144 svf_para.hdr_para.len);
1145 i += svf_para.hdr_para.len;
1146 buf_set_buf(svf_para.sdr_para.tdi,
1147 0,
1148 &svf_tdi_buffer[svf_buffer_index],
1149 i,
1150 svf_para.sdr_para.len);
1151 i += svf_para.sdr_para.len;
1152 buf_set_buf(svf_para.tdr_para.tdi,
1153 0,
1154 &svf_tdi_buffer[svf_buffer_index],
1155 i,
1156 svf_para.tdr_para.len);
1157 i += svf_para.tdr_para.len;
1158
1159 /* add check data */
1160 if (svf_para.sdr_para.data_mask & XXR_TDO) {
1161 /* assemble dr mask data */
1162 i = 0;
1163 buf_set_buf(svf_para.hdr_para.mask,
1164 0,
1165 &svf_mask_buffer[svf_buffer_index],
1166 i,
1167 svf_para.hdr_para.len);
1168 i += svf_para.hdr_para.len;
1169 buf_set_buf(svf_para.sdr_para.mask,
1170 0,
1171 &svf_mask_buffer[svf_buffer_index],
1172 i,
1173 svf_para.sdr_para.len);
1174 i += svf_para.sdr_para.len;
1175 buf_set_buf(svf_para.tdr_para.mask,
1176 0,
1177 &svf_mask_buffer[svf_buffer_index],
1178 i,
1179 svf_para.tdr_para.len);
1180
1181 /* assemble dr check data */
1182 i = 0;
1183 buf_set_buf(svf_para.hdr_para.tdo,
1184 0,
1185 &svf_tdo_buffer[svf_buffer_index],
1186 i,
1187 svf_para.hdr_para.len);
1188 i += svf_para.hdr_para.len;
1189 buf_set_buf(svf_para.sdr_para.tdo,
1190 0,
1191 &svf_tdo_buffer[svf_buffer_index],
1192 i,
1193 svf_para.sdr_para.len);
1194 i += svf_para.sdr_para.len;
1195 buf_set_buf(svf_para.tdr_para.tdo,
1196 0,
1197 &svf_tdo_buffer[svf_buffer_index],
1198 i,
1199 svf_para.tdr_para.len);
1200 i += svf_para.tdr_para.len;
1201
1202 svf_add_check_para(1, svf_buffer_index, i);
1203 } else
1204 svf_add_check_para(0, svf_buffer_index, i);
1205 field.num_bits = i;
1206 field.out_value = &svf_tdi_buffer[svf_buffer_index];
1207 field.in_value = (xxr_para_tmp->data_mask & XXR_TDO) ? &svf_tdi_buffer[svf_buffer_index] : NULL;
1208 if (!svf_nil) {
1209 /* NOTE: doesn't use SVF-specified state paths */
1210 jtag_add_plain_dr_scan(field.num_bits,
1211 field.out_value,
1212 field.in_value,
1213 svf_para.dr_end_state);
1214 }
1215
1216 if (svf_addcycles)
1217 jtag_add_clocks(svf_addcycles);
1218
1219 svf_buffer_index += (i + 7) >> 3;
1220 } else if (command == SIR) {
1221 /* check buffer size first, reallocate if necessary */
1222 i = svf_para.hir_para.len + svf_para.sir_para.len +
1223 svf_para.tir_para.len;
1224 if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3)) {
1225 if (svf_realloc_buffers(svf_buffer_index + ((i + 7) >> 3)) != ERROR_OK) {
1226 LOG_ERROR("not enough memory");
1227 return ERROR_FAIL;
1228 }
1229 }
1230
1231 /* assemble ir data */
1232 i = 0;
1233 buf_set_buf(svf_para.hir_para.tdi,
1234 0,
1235 &svf_tdi_buffer[svf_buffer_index],
1236 i,
1237 svf_para.hir_para.len);
1238 i += svf_para.hir_para.len;
1239 buf_set_buf(svf_para.sir_para.tdi,
1240 0,
1241 &svf_tdi_buffer[svf_buffer_index],
1242 i,
1243 svf_para.sir_para.len);
1244 i += svf_para.sir_para.len;
1245 buf_set_buf(svf_para.tir_para.tdi,
1246 0,
1247 &svf_tdi_buffer[svf_buffer_index],
1248 i,
1249 svf_para.tir_para.len);
1250 i += svf_para.tir_para.len;
1251
1252 /* add check data */
1253 if (svf_para.sir_para.data_mask & XXR_TDO) {
1254 /* assemble dr mask data */
1255 i = 0;
1256 buf_set_buf(svf_para.hir_para.mask,
1257 0,
1258 &svf_mask_buffer[svf_buffer_index],
1259 i,
1260 svf_para.hir_para.len);
1261 i += svf_para.hir_para.len;
1262 buf_set_buf(svf_para.sir_para.mask,
1263 0,
1264 &svf_mask_buffer[svf_buffer_index],
1265 i,
1266 svf_para.sir_para.len);
1267 i += svf_para.sir_para.len;
1268 buf_set_buf(svf_para.tir_para.mask,
1269 0,
1270 &svf_mask_buffer[svf_buffer_index],
1271 i,
1272 svf_para.tir_para.len);
1273
1274 /* assemble dr check data */
1275 i = 0;
1276 buf_set_buf(svf_para.hir_para.tdo,
1277 0,
1278 &svf_tdo_buffer[svf_buffer_index],
1279 i,
1280 svf_para.hir_para.len);
1281 i += svf_para.hir_para.len;
1282 buf_set_buf(svf_para.sir_para.tdo,
1283 0,
1284 &svf_tdo_buffer[svf_buffer_index],
1285 i,
1286 svf_para.sir_para.len);
1287 i += svf_para.sir_para.len;
1288 buf_set_buf(svf_para.tir_para.tdo,
1289 0,
1290 &svf_tdo_buffer[svf_buffer_index],
1291 i,
1292 svf_para.tir_para.len);
1293 i += svf_para.tir_para.len;
1294
1295 svf_add_check_para(1, svf_buffer_index, i);
1296 } else
1297 svf_add_check_para(0, svf_buffer_index, i);
1298 field.num_bits = i;
1299 field.out_value = &svf_tdi_buffer[svf_buffer_index];
1300 field.in_value = (xxr_para_tmp->data_mask & XXR_TDO) ? &svf_tdi_buffer[svf_buffer_index] : NULL;
1301 if (!svf_nil) {
1302 /* NOTE: doesn't use SVF-specified state paths */
1303 jtag_add_plain_ir_scan(field.num_bits,
1304 field.out_value,
1305 field.in_value,
1306 svf_para.ir_end_state);
1307 }
1308
1309 svf_buffer_index += (i + 7) >> 3;
1310 }
1311 break;
1312 case PIO:
1313 case PIOMAP:
1314 LOG_ERROR("PIO and PIOMAP are not supported");
1315 return ERROR_FAIL;
1316 case RUNTEST:
1317 /* RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time
1318 * SEC]] [ENDSTATE end_state] */
1319 /* RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE
1320 * end_state] */
1321 if ((num_of_argu < 3) || (num_of_argu > 11)) {
1322 LOG_ERROR("invalid parameter of %s", argus[0]);
1323 return ERROR_FAIL;
1324 }
1325 /* init */
1326 run_count = 0;
1327 min_time = 0;
1328 i = 1;
1329
1330 /* run_state */
1331 i_tmp = tap_state_by_name(argus[i]);
1332 if (i_tmp != TAP_INVALID) {
1333 if (svf_tap_state_is_stable(i_tmp)) {
1334 svf_para.runtest_run_state = i_tmp;
1335
1336 /* When a run_state is specified, the new
1337 * run_state becomes the default end_state.
1338 */
1339 svf_para.runtest_end_state = i_tmp;
1340 LOG_DEBUG("\trun_state = %s", tap_state_name(i_tmp));
1341 i++;
1342 } else {
1343 LOG_ERROR("%s: %s is not a stable state", argus[0], tap_state_name(i_tmp));
1344 return ERROR_FAIL;
1345 }
1346 }
1347
1348 /* run_count run_clk */
1349 if (((i + 2) <= num_of_argu) && strcmp(argus[i + 1], "SEC")) {
1350 if (!strcmp(argus[i + 1], "TCK")) {
1351 /* clock source is TCK */
1352 run_count = atoi(argus[i]);
1353 LOG_DEBUG("\trun_count@TCK = %d", run_count);
1354 } else {
1355 LOG_ERROR("%s not supported for clock", argus[i + 1]);
1356 return ERROR_FAIL;
1357 }
1358 i += 2;
1359 }
1360 /* min_time SEC */
1361 if (((i + 2) <= num_of_argu) && !strcmp(argus[i + 1], "SEC")) {
1362 min_time = atof(argus[i]);
1363 LOG_DEBUG("\tmin_time = %fs", min_time);
1364 i += 2;
1365 }
1366 /* MAXIMUM max_time SEC */
1367 if (((i + 3) <= num_of_argu) &&
1368 !strcmp(argus[i], "MAXIMUM") && !strcmp(argus[i + 2], "SEC")) {
1369 float max_time = 0;
1370 max_time = atof(argus[i + 1]);
1371 LOG_DEBUG("\tmax_time = %fs", max_time);
1372 i += 3;
1373 }
1374 /* ENDSTATE end_state */
1375 if (((i + 2) <= num_of_argu) && !strcmp(argus[i], "ENDSTATE")) {
1376 i_tmp = tap_state_by_name(argus[i + 1]);
1377
1378 if (svf_tap_state_is_stable(i_tmp)) {
1379 svf_para.runtest_end_state = i_tmp;
1380 LOG_DEBUG("\tend_state = %s", tap_state_name(i_tmp));
1381 } else {
1382 LOG_ERROR("%s: %s is not a stable state", argus[0], tap_state_name(i_tmp));
1383 return ERROR_FAIL;
1384 }
1385 i += 2;
1386 }
1387
1388 /* all parameter should be parsed */
1389 if (i == num_of_argu) {
1390 #if 1
1391 /* FIXME handle statemove failures */
1392 uint32_t min_usec = 1000000 * min_time;
1393
1394 /* enter into run_state if necessary */
1395 if (cmd_queue_cur_state != svf_para.runtest_run_state)
1396 svf_add_statemove(svf_para.runtest_run_state);
1397
1398 /* add clocks and/or min wait */
1399 if (run_count > 0) {
1400 if (!svf_nil)
1401 jtag_add_clocks(run_count);
1402 }
1403
1404 if (min_usec > 0) {
1405 if (!svf_nil)
1406 jtag_add_sleep(min_usec);
1407 }
1408
1409 /* move to end_state if necessary */
1410 if (svf_para.runtest_end_state != svf_para.runtest_run_state)
1411 svf_add_statemove(svf_para.runtest_end_state);
1412
1413 #else
1414 if (svf_para.runtest_run_state != TAP_IDLE) {
1415 LOG_ERROR("cannot runtest in %s state",
1416 tap_state_name(svf_para.runtest_run_state));
1417 return ERROR_FAIL;
1418 }
1419
1420 if (!svf_nil)
1421 jtag_add_runtest(run_count, svf_para.runtest_end_state);
1422 #endif
1423 } else {
1424 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed",
1425 i,
1426 num_of_argu);
1427 return ERROR_FAIL;
1428 }
1429 break;
1430 case STATE:
1431 /* STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state */
1432 if (num_of_argu < 2) {
1433 LOG_ERROR("invalid parameter of %s", argus[0]);
1434 return ERROR_FAIL;
1435 }
1436 if (num_of_argu > 2) {
1437 /* STATE pathstate1 ... stable_state */
1438 path = malloc((num_of_argu - 1) * sizeof(tap_state_t));
1439 if (!path) {
1440 LOG_ERROR("not enough memory");
1441 return ERROR_FAIL;
1442 }
1443 num_of_argu--; /* num of path */
1444 i_tmp = 1; /* path is from parameter 1 */
1445 for (i = 0; i < num_of_argu; i++, i_tmp++) {
1446 path[i] = tap_state_by_name(argus[i_tmp]);
1447 if (path[i] == TAP_INVALID) {
1448 LOG_ERROR("%s: %s is not a valid state", argus[0], argus[i_tmp]);
1449 free(path);
1450 return ERROR_FAIL;
1451 }
1452 /* OpenOCD refuses paths containing TAP_RESET */
1453 if (path[i] == TAP_RESET) {
1454 /* FIXME last state MUST be stable! */
1455 if (i > 0) {
1456 if (!svf_nil)
1457 jtag_add_pathmove(i, path);
1458 }
1459 if (!svf_nil)
1460 jtag_add_tlr();
1461 num_of_argu -= i + 1;
1462 i = -1;
1463 }
1464 }
1465 if (num_of_argu > 0) {
1466 /* execute last path if necessary */
1467 if (svf_tap_state_is_stable(path[num_of_argu - 1])) {
1468 /* last state MUST be stable state */
1469 if (!svf_nil)
1470 jtag_add_pathmove(num_of_argu, path);
1471 LOG_DEBUG("\tmove to %s by path_move",
1472 tap_state_name(path[num_of_argu - 1]));
1473 } else {
1474 LOG_ERROR("%s: %s is not a stable state",
1475 argus[0],
1476 tap_state_name(path[num_of_argu - 1]));
1477 free(path);
1478 return ERROR_FAIL;
1479 }
1480 }
1481
1482 free(path);
1483 path = NULL;
1484 } else {
1485 /* STATE stable_state */
1486 state = tap_state_by_name(argus[1]);
1487 if (svf_tap_state_is_stable(state)) {
1488 LOG_DEBUG("\tmove to %s by svf_add_statemove",
1489 tap_state_name(state));
1490 /* FIXME handle statemove failures */
1491 svf_add_statemove(state);
1492 } else {
1493 LOG_ERROR("%s: %s is not a stable state",
1494 argus[0], tap_state_name(state));
1495 return ERROR_FAIL;
1496 }
1497 }
1498 break;
1499 case TRST:
1500 /* TRST trst_mode */
1501 if (num_of_argu != 2) {
1502 LOG_ERROR("invalid parameter of %s", argus[0]);
1503 return ERROR_FAIL;
1504 }
1505 if (svf_para.trst_mode != TRST_ABSENT) {
1506 if (svf_execute_tap() != ERROR_OK)
1507 return ERROR_FAIL;
1508 i_tmp = svf_find_string_in_array(argus[1],
1509 (char **)svf_trst_mode_name,
1510 ARRAY_SIZE(svf_trst_mode_name));
1511 switch (i_tmp) {
1512 case TRST_ON:
1513 if (!svf_nil)
1514 jtag_add_reset(1, 0);
1515 break;
1516 case TRST_Z:
1517 case TRST_OFF:
1518 if (!svf_nil)
1519 jtag_add_reset(0, 0);
1520 break;
1521 case TRST_ABSENT:
1522 break;
1523 default:
1524 LOG_ERROR("unknown TRST mode: %s", argus[1]);
1525 return ERROR_FAIL;
1526 }
1527 svf_para.trst_mode = i_tmp;
1528 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name[svf_para.trst_mode]);
1529 } else {
1530 LOG_ERROR("can not accept TRST command if trst_mode is ABSENT");
1531 return ERROR_FAIL;
1532 }
1533 break;
1534 default:
1535 LOG_ERROR("invalid svf command: %s", argus[0]);
1536 return ERROR_FAIL;
1537 }
1538
1539 if (!svf_quiet) {
1540 if (padding_command_skipped)
1541 LOG_USER("(Above Padding command skipped, as per -tap argument)");
1542 }
1543
1544 if (debug_level >= LOG_LVL_DEBUG) {
1545 /* for convenient debugging, execute tap if possible */
1546 if ((svf_buffer_index > 0) &&
1547 (((command != STATE) && (command != RUNTEST)) ||
1548 ((command == STATE) && (num_of_argu == 2)))) {
1549 if (svf_execute_tap() != ERROR_OK)
1550 return ERROR_FAIL;
1551
1552 /* output debug info */
1553 if ((command == SIR) || (command == SDR))
1554 SVF_BUF_LOG(DEBUG, svf_tdi_buffer, svf_check_tdo_para[0].bit_len, "TDO read");
1555 }
1556 } else {
1557 /* for fast executing, execute tap if necessary */
1558 /* half of the buffer is for the next command */
1559 if (((svf_buffer_index >= SVF_MAX_BUFFER_SIZE_TO_COMMIT) ||
1560 (svf_check_tdo_para_index >= SVF_CHECK_TDO_PARA_SIZE / 2)) &&
1561 (((command != STATE) && (command != RUNTEST)) ||
1562 ((command == STATE) && (num_of_argu == 2))))
1563 return svf_execute_tap();
1564 }
1565
1566 return ERROR_OK;
1567 }
1568
1569 static const struct command_registration svf_command_handlers[] = {
1570 {
1571 .name = "svf",
1572 .handler = handle_svf_command,
1573 .mode = COMMAND_EXEC,
1574 .help = "Runs a SVF file.",
1575 .usage = "[-tap device.tap] <file> [quiet] [nil] [progress] [ignore_error] [-noreset] [-addcycles numcycles]",
1576 },
1577 COMMAND_REGISTRATION_DONE
1578 };
1579
1580 int svf_register_commands(struct command_context *cmd_ctx)
1581 {
1582 return register_commands(cmd_ctx, NULL, svf_command_handlers);
1583 }
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)