Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
armv7a_mmu: s/LOG_ERROR/LOG_WARNING/ on address translation failure
[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, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
18
19 /* The specification for SVF is available here:
20 * http://www.asset-intertech.com/support/svf.pdf
21 * Below, this document is refered to as the "SVF spec".
22 *
23 * The specification for XSVF is available here:
24 * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
25 * Below, this document is refered to as the "XSVF spec".
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <jtag/jtag.h>
33 #include "svf.h"
34 #include <helper/time_support.h>
35
36 /* SVF command */
37 enum svf_command {
38 ENDDR,
39 ENDIR,
40 FREQUENCY,
41 HDR,
42 HIR,
43 PIO,
44 PIOMAP,
45 RUNTEST,
46 SDR,
47 SIR,
48 STATE,
49 TDR,
50 TIR,
51 TRST,
52 };
53
54 static const char *svf_command_name[14] = {
55 "ENDDR",
56 "ENDIR",
57 "FREQUENCY",
58 "HDR",
59 "HIR",
60 "PIO",
61 "PIOMAP",
62 "RUNTEST",
63 "SDR",
64 "SIR",
65 "STATE",
66 "TDR",
67 "TIR",
68 "TRST"
69 };
70
71 enum trst_mode {
72 TRST_ON,
73 TRST_OFF,
74 TRST_Z,
75 TRST_ABSENT
76 };
77
78 static const char *svf_trst_mode_name[4] = {
79 "ON",
80 "OFF",
81 "Z",
82 "ABSENT"
83 };
84
85 struct svf_statemove {
86 tap_state_t from;
87 tap_state_t to;
88 uint32_t num_of_moves;
89 tap_state_t paths[8];
90 };
91
92 /*
93 * These paths are from the SVF specification for the STATE command, to be
94 * used when the STATE command only includes the final state. The first
95 * element of the path is the "from" (current) state, and the last one is
96 * the "to" (target) state.
97 *
98 * All specified paths are the shortest ones in the JTAG spec, and are thus
99 * not (!!) exact matches for the paths used elsewhere in OpenOCD. Note
100 * that PAUSE-to-PAUSE transitions all go through UPDATE and then CAPTURE,
101 * which has specific effects on the various registers; they are not NOPs.
102 *
103 * Paths to RESET are disabled here. As elsewhere in OpenOCD, and in XSVF
104 * and many SVF implementations, we don't want to risk missing that state.
105 * To get to RESET, always we ignore the current state.
106 */
107 static const struct svf_statemove svf_statemoves[] = {
108 /* from to num_of_moves, paths[8] */
109 /* {TAP_RESET, TAP_RESET, 1, {TAP_RESET}}, */
110 {TAP_RESET, TAP_IDLE, 2, {TAP_RESET, TAP_IDLE} },
111 {TAP_RESET, TAP_DRPAUSE, 6, {TAP_RESET, TAP_IDLE, TAP_DRSELECT,
112 TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE} },
113 {TAP_RESET, TAP_IRPAUSE, 7, {TAP_RESET, TAP_IDLE, TAP_DRSELECT,
114 TAP_IRSELECT, TAP_IRCAPTURE,
115 TAP_IREXIT1, TAP_IRPAUSE} },
116
117 /* {TAP_IDLE, TAP_RESET, 4, {TAP_IDLE,
118 * TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}}, */
119 {TAP_IDLE, TAP_IDLE, 1, {TAP_IDLE} },
120 {TAP_IDLE, TAP_DRPAUSE, 5, {TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE,
121 TAP_DREXIT1, TAP_DRPAUSE} },
122 {TAP_IDLE, TAP_IRPAUSE, 6, {TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT,
123 TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE} },
124
125 /* {TAP_DRPAUSE, TAP_RESET, 6, {TAP_DRPAUSE,
126 * TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}}, */
127 {TAP_DRPAUSE, TAP_IDLE, 4, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE,
128 TAP_IDLE} },
129 {TAP_DRPAUSE, TAP_DRPAUSE, 7, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE,
130 TAP_DRSELECT, TAP_DRCAPTURE,
131 TAP_DREXIT1, TAP_DRPAUSE} },
132 {TAP_DRPAUSE, TAP_IRPAUSE, 8, {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE,
133 TAP_DRSELECT, TAP_IRSELECT,
134 TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE} },
135
136 /* {TAP_IRPAUSE, TAP_RESET, 6, {TAP_IRPAUSE,
137 * TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}}, */
138 {TAP_IRPAUSE, TAP_IDLE, 4, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE,
139 TAP_IDLE} },
140 {TAP_IRPAUSE, TAP_DRPAUSE, 7, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE,
141 TAP_DRSELECT, TAP_DRCAPTURE,
142 TAP_DREXIT1, TAP_DRPAUSE} },
143 {TAP_IRPAUSE, TAP_IRPAUSE, 8, {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE,
144 TAP_DRSELECT, TAP_IRSELECT,
145 TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE} }
146 };
147
148 #define XXR_TDI (1 << 0)
149 #define XXR_TDO (1 << 1)
150 #define XXR_MASK (1 << 2)
151 #define XXR_SMASK (1 << 3)
152 struct svf_xxr_para {
153 int len;
154 int data_mask;
155 uint8_t *tdi;
156 uint8_t *tdo;
157 uint8_t *mask;
158 uint8_t *smask;
159 };
160
161 struct svf_para {
162 float frequency;
163 tap_state_t ir_end_state;
164 tap_state_t dr_end_state;
165 tap_state_t runtest_run_state;
166 tap_state_t runtest_end_state;
167 enum trst_mode trst_mode;
168
169 struct svf_xxr_para hir_para;
170 struct svf_xxr_para hdr_para;
171 struct svf_xxr_para tir_para;
172 struct svf_xxr_para tdr_para;
173 struct svf_xxr_para sir_para;
174 struct svf_xxr_para sdr_para;
175 };
176
177 static struct svf_para svf_para;
178 static const struct svf_para svf_para_init = {
179 /* frequency, ir_end_state, dr_end_state, runtest_run_state, runtest_end_state, trst_mode */
180 0, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TRST_Z,
181 /* hir_para */
182 /* {len, data_mask, tdi, tdo, mask, smask}, */
183 {0, 0, NULL, NULL, NULL, NULL},
184 /* hdr_para */
185 /* {len, data_mask, tdi, tdo, mask, smask}, */
186 {0, 0, NULL, NULL, NULL, NULL},
187 /* tir_para */
188 /* {len, data_mask, tdi, tdo, mask, smask}, */
189 {0, 0, NULL, NULL, NULL, NULL},
190 /* tdr_para */
191 /* {len, data_mask, tdi, tdo, mask, smask}, */
192 {0, 0, NULL, NULL, NULL, NULL},
193 /* sir_para */
194 /* {len, data_mask, tdi, tdo, mask, smask}, */
195 {0, 0, NULL, NULL, NULL, NULL},
196 /* sdr_para */
197 /* {len, data_mask, tdi, tdo, mask, smask}, */
198 {0, 0, NULL, NULL, NULL, NULL},
199 };
200
201 struct svf_check_tdo_para {
202 int line_num; /* used to record line number of the check operation */
203 /* so more information could be printed */
204 int enabled; /* check is enabled or not */
205 int buffer_offset; /* buffer_offset to buffers */
206 int bit_len; /* bit length to check */
207 };
208
209 #define SVF_CHECK_TDO_PARA_SIZE 1024
210 static struct svf_check_tdo_para *svf_check_tdo_para;
211 static int svf_check_tdo_para_index;
212
213 static int svf_read_command_from_file(FILE *fd);
214 static int svf_check_tdo(void);
215 static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len);
216 static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str);
217 static int svf_execute_tap(void);
218
219 static FILE *svf_fd;
220 static char *svf_read_line;
221 static size_t svf_read_line_size;
222 static char *svf_command_buffer;
223 static size_t svf_command_buffer_size;
224 static int svf_line_number;
225 static int svf_getline(char **lineptr, size_t *n, FILE *stream);
226
227 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT (1024 * 1024)
228 static uint8_t *svf_tdi_buffer, *svf_tdo_buffer, *svf_mask_buffer;
229 static int svf_buffer_index, svf_buffer_size ;
230 static int svf_quiet;
231 static int svf_nil;
232 static int svf_ignore_error;
233
234 /* Targetting particular tap */
235 static int svf_tap_is_specified;
236 static int svf_set_padding(struct svf_xxr_para *para, int len, unsigned char tdi);
237
238 /* Progress Indicator */
239 static int svf_progress_enabled;
240 static long svf_total_lines;
241 static int svf_percentage;
242 static int svf_last_printed_percentage = -1;
243
244 /*
245 * macro is used to print the svf hex buffer at desired debug level
246 * DEBUG, INFO, ERROR, USER
247 */
248 #define SVF_BUF_LOG(_lvl, _buf, _nbits, _desc) \
249 svf_hexbuf_print(LOG_LVL_##_lvl , __FILE__, __LINE__, __func__, _buf, _nbits, _desc)
250
251 static void svf_hexbuf_print(int dbg_lvl, const char *file, unsigned line,
252 const char *function, const uint8_t *buf,
253 int bit_len, const char *desc)
254 {
255 int j, len = 0;
256 int byte_len = DIV_ROUND_UP(bit_len, 8);
257 int msbits = bit_len % 8;
258
259 /* allocate 2 bytes per hex digit */
260 char *prbuf = malloc((byte_len * 2) + 2 + 1);
261 if (!prbuf)
262 return;
263
264 /* print correct number of bytes, mask excess bits where applicable */
265 uint8_t msb = buf[byte_len - 1] & (msbits ? (1 << msbits) - 1 : 0xff);
266 len = sprintf(prbuf, msbits <= 4 ? "0x%01"PRIx8 : "0x%02"PRIx8, msb);
267 for (j = byte_len - 2; j >= 0; j--)
268 len += sprintf(prbuf + len, "%02"PRIx8, buf[j]);
269
270 log_printf_lf(dbg_lvl, file, line, function, "%8s = %s", desc ? desc : " ", prbuf);
271
272 free(prbuf);
273 }
274
275 static int svf_realloc_buffers(size_t len)
276 {
277 void *ptr;
278
279 if (svf_execute_tap() != ERROR_OK)
280 return ERROR_FAIL;
281
282 ptr = realloc(svf_tdi_buffer, len);
283 if (!ptr)
284 return ERROR_FAIL;
285 svf_tdi_buffer = ptr;
286
287 ptr = realloc(svf_tdo_buffer, len);
288 if (!ptr)
289 return ERROR_FAIL;
290 svf_tdo_buffer = ptr;
291
292 ptr = realloc(svf_mask_buffer, len);
293 if (!ptr)
294 return ERROR_FAIL;
295 svf_mask_buffer = ptr;
296
297 svf_buffer_size = len;
298
299 return ERROR_OK;
300 }
301
302 static void svf_free_xxd_para(struct svf_xxr_para *para)
303 {
304 if (NULL != para) {
305 if (para->tdi != NULL) {
306 free(para->tdi);
307 para->tdi = NULL;
308 }
309 if (para->tdo != NULL) {
310 free(para->tdo);
311 para->tdo = NULL;
312 }
313 if (para->mask != NULL) {
314 free(para->mask);
315 para->mask = NULL;
316 }
317 if (para->smask != NULL) {
318 free(para->smask);
319 para->smask = NULL;
320 }
321 }
322 }
323
324 int svf_add_statemove(tap_state_t state_to)
325 {
326 tap_state_t state_from = cmd_queue_cur_state;
327 unsigned index_var;
328
329 /* when resetting, be paranoid and ignore current state */
330 if (state_to == TAP_RESET) {
331 if (svf_nil)
332 return ERROR_OK;
333
334 jtag_add_tlr();
335 return ERROR_OK;
336 }
337
338 for (index_var = 0; index_var < ARRAY_SIZE(svf_statemoves); index_var++) {
339 if ((svf_statemoves[index_var].from == state_from)
340 && (svf_statemoves[index_var].to == state_to)) {
341 if (svf_nil)
342 continue;
343 /* recorded path includes current state ... avoid
344 *extra TCKs! */
345 if (svf_statemoves[index_var].num_of_moves > 1)
346 jtag_add_pathmove(svf_statemoves[index_var].num_of_moves - 1,
347 svf_statemoves[index_var].paths + 1);
348 else
349 jtag_add_pathmove(svf_statemoves[index_var].num_of_moves,
350 svf_statemoves[index_var].paths);
351 return ERROR_OK;
352 }
353 }
354 LOG_ERROR("SVF: can not move to %s", tap_state_name(state_to));
355 return ERROR_FAIL;
356 }
357
358 COMMAND_HANDLER(handle_svf_command)
359 {
360 #define SVF_MIN_NUM_OF_OPTIONS 1
361 #define SVF_MAX_NUM_OF_OPTIONS 5
362 int command_num = 0;
363 int ret = ERROR_OK;
364 int64_t time_measure_ms;
365 int time_measure_s, time_measure_m;
366
367 /* use NULL to indicate a "plain" svf file which accounts for
368 * any additional devices in the scan chain, otherwise the device
369 * that should be affected
370 */
371 struct jtag_tap *tap = NULL;
372
373 if ((CMD_ARGC < SVF_MIN_NUM_OF_OPTIONS) || (CMD_ARGC > SVF_MAX_NUM_OF_OPTIONS))
374 return ERROR_COMMAND_SYNTAX_ERROR;
375
376 /* parse command line */
377 svf_quiet = 0;
378 svf_nil = 0;
379 svf_progress_enabled = 0;
380 svf_ignore_error = 0;
381 for (unsigned int i = 0; i < CMD_ARGC; i++) {
382 if (strcmp(CMD_ARGV[i], "-tap") == 0) {
383 tap = jtag_tap_by_string(CMD_ARGV[i+1]);
384 if (!tap) {
385 command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i+1]);
386 return ERROR_FAIL;
387 }
388 i++;
389 } else if ((strcmp(CMD_ARGV[i],
390 "quiet") == 0) || (strcmp(CMD_ARGV[i], "-quiet") == 0))
391 svf_quiet = 1;
392 else if ((strcmp(CMD_ARGV[i], "nil") == 0) || (strcmp(CMD_ARGV[i], "-nil") == 0))
393 svf_nil = 1;
394 else if ((strcmp(CMD_ARGV[i],
395 "progress") == 0) || (strcmp(CMD_ARGV[i], "-progress") == 0))
396 svf_progress_enabled = 1;
397 else if ((strcmp(CMD_ARGV[i],
398 "ignore_error") == 0) || (strcmp(CMD_ARGV[i], "-ignore_error") == 0))
399 svf_ignore_error = 1;
400 else {
401 svf_fd = fopen(CMD_ARGV[i], "r");
402 if (svf_fd == NULL) {
403 int err = errno;
404 command_print(CMD_CTX, "open(\"%s\"): %s", CMD_ARGV[i], strerror(err));
405 /* no need to free anything now */
406 return ERROR_COMMAND_SYNTAX_ERROR;
407 } else
408 LOG_USER("svf processing file: \"%s\"", CMD_ARGV[i]);
409 }
410 }
411
412 if (svf_fd == NULL)
413 return ERROR_COMMAND_SYNTAX_ERROR;
414
415 /* get time */
416 time_measure_ms = timeval_ms();
417
418 /* init */
419 svf_line_number = 0;
420 svf_command_buffer_size = 0;
421
422 svf_check_tdo_para_index = 0;
423 svf_check_tdo_para = malloc(sizeof(struct svf_check_tdo_para) * SVF_CHECK_TDO_PARA_SIZE);
424 if (NULL == svf_check_tdo_para) {
425 LOG_ERROR("not enough memory");
426 ret = ERROR_FAIL;
427 goto free_all;
428 }
429
430 svf_buffer_index = 0;
431 /* double the buffer size */
432 /* in case current command cannot be committed, and next command is a bit scan command */
433 /* here is 32K bits for this big scan command, it should be enough */
434 /* buffer will be reallocated if buffer size is not enough */
435 if (svf_realloc_buffers(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT) != ERROR_OK) {
436 ret = ERROR_FAIL;
437 goto free_all;
438 }
439
440 memcpy(&svf_para, &svf_para_init, sizeof(svf_para));
441
442 if (!svf_nil) {
443 /* TAP_RESET */
444 jtag_add_tlr();
445 }
446
447 if (tap) {
448 /* Tap is specified, set header/trailer paddings */
449 int header_ir_len = 0, header_dr_len = 0, trailer_ir_len = 0, trailer_dr_len = 0;
450 struct jtag_tap *check_tap;
451
452 svf_tap_is_specified = 1;
453
454 for (check_tap = jtag_all_taps(); check_tap; check_tap = check_tap->next_tap) {
455 if (check_tap->abs_chain_position < tap->abs_chain_position) {
456 /* Header */
457 header_ir_len += check_tap->ir_length;
458 header_dr_len++;
459 } else if (check_tap->abs_chain_position > tap->abs_chain_position) {
460 /* Trailer */
461 trailer_ir_len += check_tap->ir_length;
462 trailer_dr_len++;
463 }
464 }
465
466 /* HDR %d TDI (0) */
467 if (ERROR_OK != svf_set_padding(&svf_para.hdr_para, header_dr_len, 0)) {
468 LOG_ERROR("failed to set data header");
469 return ERROR_FAIL;
470 }
471
472 /* HIR %d TDI (0xFF) */
473 if (ERROR_OK != svf_set_padding(&svf_para.hir_para, header_ir_len, 0xFF)) {
474 LOG_ERROR("failed to set instruction header");
475 return ERROR_FAIL;
476 }
477
478 /* TDR %d TDI (0) */
479 if (ERROR_OK != svf_set_padding(&svf_para.tdr_para, trailer_dr_len, 0)) {
480 LOG_ERROR("failed to set data trailer");
481 return ERROR_FAIL;
482 }
483
484 /* TIR %d TDI (0xFF) */
485 if (ERROR_OK != svf_set_padding(&svf_para.tir_para, trailer_ir_len, 0xFF)) {
486 LOG_ERROR("failed to set instruction trailer");
487 return ERROR_FAIL;
488 }
489 }
490
491 if (svf_progress_enabled) {
492 /* Count total lines in file. */
493 while (!feof(svf_fd)) {
494 svf_getline(&svf_command_buffer, &svf_command_buffer_size, svf_fd);
495 svf_total_lines++;
496 }
497 rewind(svf_fd);
498 }
499 while (ERROR_OK == svf_read_command_from_file(svf_fd)) {
500 /* Log Output */
501 if (svf_quiet) {
502 if (svf_progress_enabled) {
503 svf_percentage = ((svf_line_number * 20) / svf_total_lines) * 5;
504 if (svf_last_printed_percentage != svf_percentage) {
505 LOG_USER_N("\r%d%% ", svf_percentage);
506 svf_last_printed_percentage = svf_percentage;
507 }
508 }
509 } else {
510 if (svf_progress_enabled) {
511 svf_percentage = ((svf_line_number * 20) / svf_total_lines) * 5;
512 LOG_USER_N("%3d%% %s", svf_percentage, svf_read_line);
513 } else
514 LOG_USER_N("%s", svf_read_line);
515 }
516 /* Run Command */
517 if (ERROR_OK != svf_run_command(CMD_CTX, svf_command_buffer)) {
518 LOG_ERROR("fail to run command at line %d", svf_line_number);
519 ret = ERROR_FAIL;
520 break;
521 }
522 command_num++;
523 }
524
525 if ((!svf_nil) && (ERROR_OK != jtag_execute_queue()))
526 ret = ERROR_FAIL;
527 else if (ERROR_OK != svf_check_tdo())
528 ret = ERROR_FAIL;
529
530 /* print time */
531 time_measure_ms = timeval_ms() - time_measure_ms;
532 time_measure_s = time_measure_ms / 1000;
533 time_measure_ms %= 1000;
534 time_measure_m = time_measure_s / 60;
535 time_measure_s %= 60;
536 if (time_measure_ms < 1000)
537 command_print(CMD_CTX,
538 "\r\nTime used: %dm%ds%" PRId64 "ms ",
539 time_measure_m,
540 time_measure_s,
541 time_measure_ms);
542
543 free_all:
544
545 fclose(svf_fd);
546 svf_fd = 0;
547
548 /* free buffers */
549 if (svf_command_buffer) {
550 free(svf_command_buffer);
551 svf_command_buffer = NULL;
552 svf_command_buffer_size = 0;
553 }
554 if (svf_check_tdo_para) {
555 free(svf_check_tdo_para);
556 svf_check_tdo_para = NULL;
557 svf_check_tdo_para_index = 0;
558 }
559 if (svf_tdi_buffer) {
560 free(svf_tdi_buffer);
561 svf_tdi_buffer = NULL;
562 }
563 if (svf_tdo_buffer) {
564 free(svf_tdo_buffer);
565 svf_tdo_buffer = NULL;
566 }
567 if (svf_mask_buffer) {
568 free(svf_mask_buffer);
569 svf_mask_buffer = NULL;
570 }
571 svf_buffer_index = 0;
572 svf_buffer_size = 0;
573
574 svf_free_xxd_para(&svf_para.hdr_para);
575 svf_free_xxd_para(&svf_para.hir_para);
576 svf_free_xxd_para(&svf_para.tdr_para);
577 svf_free_xxd_para(&svf_para.tir_para);
578 svf_free_xxd_para(&svf_para.sdr_para);
579 svf_free_xxd_para(&svf_para.sir_para);
580
581 if (ERROR_OK == ret)
582 command_print(CMD_CTX,
583 "svf file programmed %s for %d commands with %d errors",
584 (svf_ignore_error > 1) ? "unsuccessfully" : "successfully",
585 command_num,
586 (svf_ignore_error > 1) ? (svf_ignore_error - 1) : 0);
587 else
588 command_print(CMD_CTX, "svf file programmed failed");
589
590 svf_ignore_error = 0;
591 return ret;
592 }
593
594 static int svf_getline(char **lineptr, size_t *n, FILE *stream)
595 {
596 #define MIN_CHUNK 16 /* Buffer is increased by this size each time as required */
597 size_t i = 0;
598
599 if (*lineptr == NULL) {
600 *n = MIN_CHUNK;
601 *lineptr = malloc(*n);
602 if (!*lineptr)
603 return -1;
604 }
605
606 (*lineptr)[0] = fgetc(stream);
607 while ((*lineptr)[i] != '\n') {
608 (*lineptr)[++i] = fgetc(stream);
609 if (feof(stream)) {
610 (*lineptr)[0] = 0;
611 return -1;
612 }
613 if ((i + 2) > *n) {
614 *n += MIN_CHUNK;
615 *lineptr = realloc(*lineptr, *n);
616 }
617 }
618
619 (*lineptr)[++i] = 0;
620
621 return sizeof(*lineptr);
622 }
623
624 #define SVFP_CMD_INC_CNT 1024
625 static int svf_read_command_from_file(FILE *fd)
626 {
627 unsigned char ch;
628 int i = 0;
629 size_t cmd_pos = 0;
630 int cmd_ok = 0, slash = 0;
631
632 if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
633 return ERROR_FAIL;
634 svf_line_number++;
635 ch = svf_read_line[0];
636 while (!cmd_ok && (ch != 0)) {
637 switch (ch) {
638 case '!':
639 slash = 0;
640 if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
641 return ERROR_FAIL;
642 svf_line_number++;
643 i = -1;
644 break;
645 case '/':
646 if (++slash == 2) {
647 slash = 0;
648 if (svf_getline(&svf_read_line, &svf_read_line_size,
649 svf_fd) <= 0)
650 return ERROR_FAIL;
651 svf_line_number++;
652 i = -1;
653 }
654 break;
655 case ';':
656 slash = 0;
657 cmd_ok = 1;
658 break;
659 case '\n':
660 svf_line_number++;
661 if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
662 return ERROR_FAIL;
663 i = -1;
664 /* fallthrough */
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 /* fallthrough */
671 default:
672 /* The parsing code currently expects a space
673 * before parentheses -- "TDI (123)". Also a
674 * space afterwards -- "TDI (123) TDO(456)".
675 * But such spaces are optional... instead of
676 * parser updates, cope with that by adding the
677 * spaces as needed.
678 *
679 * Ensure there are 3 bytes available, for:
680 * - current character
681 * - added space.
682 * - terminating NUL ('\0')
683 */
684 if (cmd_pos + 3 > svf_command_buffer_size) {
685 svf_command_buffer = realloc(svf_command_buffer, cmd_pos + 3);
686 svf_command_buffer_size = cmd_pos + 3;
687 if (svf_command_buffer == NULL) {
688 LOG_ERROR("not enough memory");
689 return ERROR_FAIL;
690 }
691 }
692
693 /* insert a space before '(' */
694 if ('(' == ch)
695 svf_command_buffer[cmd_pos++] = ' ';
696
697 svf_command_buffer[cmd_pos++] = (char)toupper(ch);
698
699 /* insert a space after ')' */
700 if (')' == ch)
701 svf_command_buffer[cmd_pos++] = ' ';
702 break;
703 }
704 ch = svf_read_line[++i];
705 }
706
707 if (cmd_ok) {
708 svf_command_buffer[cmd_pos] = '\0';
709 return ERROR_OK;
710 } else
711 return ERROR_FAIL;
712 }
713
714 static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_argu)
715 {
716 int pos = 0, num = 0, space_found = 1, in_bracket = 0;
717
718 while (pos < len) {
719 switch (str[pos]) {
720 case '!':
721 case '/':
722 LOG_ERROR("fail to parse svf command");
723 return ERROR_FAIL;
724 case '(':
725 in_bracket = 1;
726 goto parse_char;
727 case ')':
728 in_bracket = 0;
729 goto parse_char;
730 default:
731 parse_char:
732 if (!in_bracket && isspace((int) str[pos])) {
733 space_found = 1;
734 str[pos] = '\0';
735 } else if (space_found) {
736 argus[num++] = &str[pos];
737 space_found = 0;
738 }
739 break;
740 }
741 pos++;
742 }
743
744 if (num == 0)
745 return ERROR_FAIL;
746
747 *num_of_argu = num;
748
749 return ERROR_OK;
750 }
751
752 bool svf_tap_state_is_stable(tap_state_t state)
753 {
754 return (TAP_RESET == state) || (TAP_IDLE == state)
755 || (TAP_DRPAUSE == state) || (TAP_IRPAUSE == state);
756 }
757
758 static int svf_find_string_in_array(char *str, char **strs, int num_of_element)
759 {
760 int i;
761
762 for (i = 0; i < num_of_element; i++) {
763 if (!strcmp(str, strs[i]))
764 return i;
765 }
766 return 0xFF;
767 }
768
769 static int svf_adjust_array_length(uint8_t **arr, int orig_bit_len, int new_bit_len)
770 {
771 int new_byte_len = (new_bit_len + 7) >> 3;
772
773 if ((NULL == *arr) || (((orig_bit_len + 7) >> 3) < ((new_bit_len + 7) >> 3))) {
774 if (*arr != NULL) {
775 free(*arr);
776 *arr = NULL;
777 }
778 *arr = malloc(new_byte_len);
779 if (NULL == *arr) {
780 LOG_ERROR("not enough memory");
781 return ERROR_FAIL;
782 }
783 memset(*arr, 0, new_byte_len);
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 (ERROR_OK != svf_adjust_array_length(bin, orig_bit_len, bit_len)) {
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 execeeds 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) && (ERROR_OK != jtag_execute_queue()))
910 return ERROR_FAIL;
911 else if (ERROR_OK != svf_check_tdo())
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 (ERROR_OK != svf_parse_cmd_string(cmd_str, strlen(cmd_str), argus, &num_of_argu))
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 (1 == num_of_argu) {
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 (ERROR_OK != svf_execute_tap())
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_khz %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("unknow 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 (NULL == 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 (NULL == 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 (SDR == command) {
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 svf_buffer_index += (i + 7) >> 3;
1217 } else if (SIR == command) {
1218 /* check buffer size first, reallocate if necessary */
1219 i = svf_para.hir_para.len + svf_para.sir_para.len +
1220 svf_para.tir_para.len;
1221 if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3)) {
1222 if (svf_realloc_buffers(svf_buffer_index + ((i + 7) >> 3)) != ERROR_OK) {
1223 LOG_ERROR("not enough memory");
1224 return ERROR_FAIL;
1225 }
1226 }
1227
1228 /* assemble ir data */
1229 i = 0;
1230 buf_set_buf(svf_para.hir_para.tdi,
1231 0,
1232 &svf_tdi_buffer[svf_buffer_index],
1233 i,
1234 svf_para.hir_para.len);
1235 i += svf_para.hir_para.len;
1236 buf_set_buf(svf_para.sir_para.tdi,
1237 0,
1238 &svf_tdi_buffer[svf_buffer_index],
1239 i,
1240 svf_para.sir_para.len);
1241 i += svf_para.sir_para.len;
1242 buf_set_buf(svf_para.tir_para.tdi,
1243 0,
1244 &svf_tdi_buffer[svf_buffer_index],
1245 i,
1246 svf_para.tir_para.len);
1247 i += svf_para.tir_para.len;
1248
1249 /* add check data */
1250 if (svf_para.sir_para.data_mask & XXR_TDO) {
1251 /* assemble dr mask data */
1252 i = 0;
1253 buf_set_buf(svf_para.hir_para.mask,
1254 0,
1255 &svf_mask_buffer[svf_buffer_index],
1256 i,
1257 svf_para.hir_para.len);
1258 i += svf_para.hir_para.len;
1259 buf_set_buf(svf_para.sir_para.mask,
1260 0,
1261 &svf_mask_buffer[svf_buffer_index],
1262 i,
1263 svf_para.sir_para.len);
1264 i += svf_para.sir_para.len;
1265 buf_set_buf(svf_para.tir_para.mask,
1266 0,
1267 &svf_mask_buffer[svf_buffer_index],
1268 i,
1269 svf_para.tir_para.len);
1270
1271 /* assemble dr check data */
1272 i = 0;
1273 buf_set_buf(svf_para.hir_para.tdo,
1274 0,
1275 &svf_tdo_buffer[svf_buffer_index],
1276 i,
1277 svf_para.hir_para.len);
1278 i += svf_para.hir_para.len;
1279 buf_set_buf(svf_para.sir_para.tdo,
1280 0,
1281 &svf_tdo_buffer[svf_buffer_index],
1282 i,
1283 svf_para.sir_para.len);
1284 i += svf_para.sir_para.len;
1285 buf_set_buf(svf_para.tir_para.tdo,
1286 0,
1287 &svf_tdo_buffer[svf_buffer_index],
1288 i,
1289 svf_para.tir_para.len);
1290 i += svf_para.tir_para.len;
1291
1292 svf_add_check_para(1, svf_buffer_index, i);
1293 } else
1294 svf_add_check_para(0, svf_buffer_index, i);
1295 field.num_bits = i;
1296 field.out_value = &svf_tdi_buffer[svf_buffer_index];
1297 field.in_value = (xxr_para_tmp->data_mask & XXR_TDO) ? &svf_tdi_buffer[svf_buffer_index] : NULL;
1298 if (!svf_nil) {
1299 /* NOTE: doesn't use SVF-specified state paths */
1300 jtag_add_plain_ir_scan(field.num_bits,
1301 field.out_value,
1302 field.in_value,
1303 svf_para.ir_end_state);
1304 }
1305
1306 svf_buffer_index += (i + 7) >> 3;
1307 }
1308 break;
1309 case PIO:
1310 case PIOMAP:
1311 LOG_ERROR("PIO and PIOMAP are not supported");
1312 return ERROR_FAIL;
1313 break;
1314 case RUNTEST:
1315 /* RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time
1316 * SEC]] [ENDSTATE end_state] */
1317 /* RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE
1318 * end_state] */
1319 if ((num_of_argu < 3) || (num_of_argu > 11)) {
1320 LOG_ERROR("invalid parameter of %s", argus[0]);
1321 return ERROR_FAIL;
1322 }
1323 /* init */
1324 run_count = 0;
1325 min_time = 0;
1326 i = 1;
1327
1328 /* run_state */
1329 i_tmp = tap_state_by_name(argus[i]);
1330 if (i_tmp != TAP_INVALID) {
1331 if (svf_tap_state_is_stable(i_tmp)) {
1332 svf_para.runtest_run_state = i_tmp;
1333
1334 /* When a run_state is specified, the new
1335 * run_state becomes the default end_state.
1336 */
1337 svf_para.runtest_end_state = i_tmp;
1338 LOG_DEBUG("\trun_state = %s", tap_state_name(i_tmp));
1339 i++;
1340 } else {
1341 LOG_ERROR("%s: %s is not a stable state", argus[0], tap_state_name(i_tmp));
1342 return ERROR_FAIL;
1343 }
1344 }
1345
1346 /* run_count run_clk */
1347 if (((i + 2) <= num_of_argu) && strcmp(argus[i + 1], "SEC")) {
1348 if (!strcmp(argus[i + 1], "TCK")) {
1349 /* clock source is TCK */
1350 run_count = atoi(argus[i]);
1351 LOG_DEBUG("\trun_count@TCK = %d", run_count);
1352 } else {
1353 LOG_ERROR("%s not supported for clock", argus[i + 1]);
1354 return ERROR_FAIL;
1355 }
1356 i += 2;
1357 }
1358 /* min_time SEC */
1359 if (((i + 2) <= num_of_argu) && !strcmp(argus[i + 1], "SEC")) {
1360 min_time = atof(argus[i]);
1361 LOG_DEBUG("\tmin_time = %fs", min_time);
1362 i += 2;
1363 }
1364 /* MAXIMUM max_time SEC */
1365 if (((i + 3) <= num_of_argu) &&
1366 !strcmp(argus[i], "MAXIMUM") && !strcmp(argus[i + 2], "SEC")) {
1367 float max_time = 0;
1368 max_time = atof(argus[i + 1]);
1369 LOG_DEBUG("\tmax_time = %fs", max_time);
1370 i += 3;
1371 }
1372 /* ENDSTATE end_state */
1373 if (((i + 2) <= num_of_argu) && !strcmp(argus[i], "ENDSTATE")) {
1374 i_tmp = tap_state_by_name(argus[i + 1]);
1375
1376 if (svf_tap_state_is_stable(i_tmp)) {
1377 svf_para.runtest_end_state = i_tmp;
1378 LOG_DEBUG("\tend_state = %s", tap_state_name(i_tmp));
1379 } else {
1380 LOG_ERROR("%s: %s is not a stable state", argus[0], tap_state_name(i_tmp));
1381 return ERROR_FAIL;
1382 }
1383 i += 2;
1384 }
1385
1386 /* all parameter should be parsed */
1387 if (i == num_of_argu) {
1388 #if 1
1389 /* FIXME handle statemove failures */
1390 uint32_t min_usec = 1000000 * min_time;
1391
1392 /* enter into run_state if necessary */
1393 if (cmd_queue_cur_state != svf_para.runtest_run_state)
1394 svf_add_statemove(svf_para.runtest_run_state);
1395
1396 /* add clocks and/or min wait */
1397 if (run_count > 0) {
1398 if (!svf_nil)
1399 jtag_add_clocks(run_count);
1400 }
1401
1402 if (min_usec > 0) {
1403 if (!svf_nil)
1404 jtag_add_sleep(min_usec);
1405 }
1406
1407 /* move to end_state if necessary */
1408 if (svf_para.runtest_end_state != svf_para.runtest_run_state)
1409 svf_add_statemove(svf_para.runtest_end_state);
1410
1411 #else
1412 if (svf_para.runtest_run_state != TAP_IDLE) {
1413 LOG_ERROR("cannot runtest in %s state",
1414 tap_state_name(svf_para.runtest_run_state));
1415 return ERROR_FAIL;
1416 }
1417
1418 if (!svf_nil)
1419 jtag_add_runtest(run_count, svf_para.runtest_end_state);
1420 #endif
1421 } else {
1422 LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed",
1423 i,
1424 num_of_argu);
1425 return ERROR_FAIL;
1426 }
1427 break;
1428 case STATE:
1429 /* STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state */
1430 if (num_of_argu < 2) {
1431 LOG_ERROR("invalid parameter of %s", argus[0]);
1432 return ERROR_FAIL;
1433 }
1434 if (num_of_argu > 2) {
1435 /* STATE pathstate1 ... stable_state */
1436 path = malloc((num_of_argu - 1) * sizeof(tap_state_t));
1437 if (NULL == path) {
1438 LOG_ERROR("not enough memory");
1439 return ERROR_FAIL;
1440 }
1441 num_of_argu--; /* num of path */
1442 i_tmp = 1; /* path is from parameter 1 */
1443 for (i = 0; i < num_of_argu; i++, i_tmp++) {
1444 path[i] = tap_state_by_name(argus[i_tmp]);
1445 if (path[i] == TAP_INVALID) {
1446 LOG_ERROR("%s: %s is not a valid state", argus[0], argus[i_tmp]);
1447 free(path);
1448 return ERROR_FAIL;
1449 }
1450 /* OpenOCD refuses paths containing TAP_RESET */
1451 if (TAP_RESET == path[i]) {
1452 /* FIXME last state MUST be stable! */
1453 if (i > 0) {
1454 if (!svf_nil)
1455 jtag_add_pathmove(i, path);
1456 }
1457 if (!svf_nil)
1458 jtag_add_tlr();
1459 num_of_argu -= i + 1;
1460 i = -1;
1461 }
1462 }
1463 if (num_of_argu > 0) {
1464 /* execute last path if necessary */
1465 if (svf_tap_state_is_stable(path[num_of_argu - 1])) {
1466 /* last state MUST be stable state */
1467 if (!svf_nil)
1468 jtag_add_pathmove(num_of_argu, path);
1469 LOG_DEBUG("\tmove to %s by path_move",
1470 tap_state_name(path[num_of_argu - 1]));
1471 } else {
1472 LOG_ERROR("%s: %s is not a stable state",
1473 argus[0],
1474 tap_state_name(path[num_of_argu - 1]));
1475 free(path);
1476 return ERROR_FAIL;
1477 }
1478 }
1479
1480 free(path);
1481 path = NULL;
1482 } else {
1483 /* STATE stable_state */
1484 state = tap_state_by_name(argus[1]);
1485 if (svf_tap_state_is_stable(state)) {
1486 LOG_DEBUG("\tmove to %s by svf_add_statemove",
1487 tap_state_name(state));
1488 /* FIXME handle statemove failures */
1489 svf_add_statemove(state);
1490 } else {
1491 LOG_ERROR("%s: %s is not a stable state",
1492 argus[0], tap_state_name(state));
1493 return ERROR_FAIL;
1494 }
1495 }
1496 break;
1497 case TRST:
1498 /* TRST trst_mode */
1499 if (num_of_argu != 2) {
1500 LOG_ERROR("invalid parameter of %s", argus[0]);
1501 return ERROR_FAIL;
1502 }
1503 if (svf_para.trst_mode != TRST_ABSENT) {
1504 if (ERROR_OK != svf_execute_tap())
1505 return ERROR_FAIL;
1506 i_tmp = svf_find_string_in_array(argus[1],
1507 (char **)svf_trst_mode_name,
1508 ARRAY_SIZE(svf_trst_mode_name));
1509 switch (i_tmp) {
1510 case TRST_ON:
1511 if (!svf_nil)
1512 jtag_add_reset(1, 0);
1513 break;
1514 case TRST_Z:
1515 case TRST_OFF:
1516 if (!svf_nil)
1517 jtag_add_reset(0, 0);
1518 break;
1519 case TRST_ABSENT:
1520 break;
1521 default:
1522 LOG_ERROR("unknown TRST mode: %s", argus[1]);
1523 return ERROR_FAIL;
1524 }
1525 svf_para.trst_mode = i_tmp;
1526 LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name[svf_para.trst_mode]);
1527 } else {
1528 LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1529 return ERROR_FAIL;
1530 }
1531 break;
1532 default:
1533 LOG_ERROR("invalid svf command: %s", argus[0]);
1534 return ERROR_FAIL;
1535 break;
1536 }
1537
1538 if (!svf_quiet) {
1539 if (padding_command_skipped)
1540 LOG_USER("(Above Padding command skipped, as per -tap argument)");
1541 }
1542
1543 if (debug_level >= LOG_LVL_DEBUG) {
1544 /* for convenient debugging, execute tap if possible */
1545 if ((svf_buffer_index > 0) && \
1546 (((command != STATE) && (command != RUNTEST)) || \
1547 ((command == STATE) && (num_of_argu == 2)))) {
1548 if (ERROR_OK != svf_execute_tap())
1549 return ERROR_FAIL;
1550
1551 /* output debug info */
1552 if ((SIR == command) || (SDR == command)) {
1553 SVF_BUF_LOG(DEBUG, svf_tdi_buffer, svf_check_tdo_para[0].bit_len, "TDO read");
1554 }
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 = "svf [-tap device.tap] <file> [quiet] [nil] [progress] [ignore_error]",
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)