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