X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fsvf%2Fsvf.c;h=0cca768d758bd76881d9893deb409c3a0cc3fb75;hp=814f3f22b8621e41afa6dd9eb54b56c3a221d893;hb=33a17fd35995a7f679f92600055a8f55ae380022;hpb=98723c4ecdbe06f90c66f3abec27b792c3b38e34

diff --git a/src/svf/svf.c b/src/svf/svf.c
index 814f3f22b8..0cca768d75 100644
--- a/src/svf/svf.c
+++ b/src/svf/svf.c
@@ -31,9 +31,9 @@
 #include "config.h"
 #endif
 
-#include "jtag.h"
+#include <jtag/jtag.h>
 #include "svf.h"
-#include "time_support.h"
+#include <helper/time_support.h>
 
 
 // SVF command
@@ -206,23 +206,34 @@ struct svf_check_tdo_para
 static struct svf_check_tdo_para *svf_check_tdo_para = NULL;
 static int svf_check_tdo_para_index = 0;
 
-static int svf_read_command_from_file(int fd);
+static int svf_read_command_from_file(FILE * fd);
 static int svf_check_tdo(void);
 static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len);
 static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str);
 
-static int svf_fd = 0;
+static FILE * svf_fd = NULL;
+static char * svf_read_line = NULL;
+static size_t svf_read_line_size = 0;
 static char *svf_command_buffer = NULL;
-static int svf_command_buffer_size = 0;
+static size_t svf_command_buffer_size = 0;
 static int svf_line_number = 1;
-
-static struct jtag_tap *tap = NULL;
+static int svf_getline (char **lineptr, size_t *n, FILE *stream);
 
 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT	(4 * 1024)
 static uint8_t *svf_tdi_buffer = NULL, *svf_tdo_buffer = NULL, *svf_mask_buffer = NULL;
 static int svf_buffer_index = 0, svf_buffer_size = 0;
 static int svf_quiet = 0;
+static int svf_nil = 0;
+
+// Targetting particular tap
+static int svf_tap_is_specified = 0;
+static int svf_set_padding(struct svf_xxr_para *para, int len, unsigned char tdi);
 
+// Progress Indicator
+static int svf_progress_enabled = 0;
+static long svf_total_lines = 0;
+static int svf_percentage = 0;
+static int svf_last_printed_percentage = -1;
 
 static void svf_free_xxd_para(struct svf_xxr_para *para)
 {
@@ -274,26 +285,33 @@ static unsigned svf_get_mask_u32(int bitlen)
 int svf_add_statemove(tap_state_t state_to)
 {
 	tap_state_t state_from = cmd_queue_cur_state;
-	uint8_t index;
+	unsigned index_var;
 
 	/* when resetting, be paranoid and ignore current state */
 	if (state_to == TAP_RESET) {
+		if (svf_nil)
+			return ERROR_OK;
+
 		jtag_add_tlr();
 		return ERROR_OK;
 	}
 
-	for (index = 0; index < DIM(svf_statemoves); index++)
+	for (index_var = 0; index_var < ARRAY_SIZE(svf_statemoves); index_var++)
 	{
-		if ((svf_statemoves[index].from == state_from)
-			&& (svf_statemoves[index].to == state_to))
+		if ((svf_statemoves[index_var].from == state_from)
+			&& (svf_statemoves[index_var].to == state_to))
 		{
+			if (svf_nil)
+			{
+				continue;
+			}
 			/* recorded path includes current state ... avoid extra TCKs! */
-			if (svf_statemoves[index].num_of_moves > 1)
-				jtag_add_pathmove(svf_statemoves[index].num_of_moves - 1,
-						svf_statemoves[index].paths + 1);
+			if (svf_statemoves[index_var].num_of_moves > 1)
+				jtag_add_pathmove(svf_statemoves[index_var].num_of_moves - 1,
+						svf_statemoves[index_var].paths + 1);
 			else
-				jtag_add_pathmove(svf_statemoves[index].num_of_moves,
-						svf_statemoves[index].paths);
+				jtag_add_pathmove(svf_statemoves[index_var].num_of_moves,
+						svf_statemoves[index_var].paths);
 			return ERROR_OK;
 		}
 	}
@@ -303,46 +321,71 @@ int svf_add_statemove(tap_state_t state_to)
 
 COMMAND_HANDLER(handle_svf_command)
 {
-#define SVF_NUM_OF_OPTIONS			1
+#define SVF_MIN_NUM_OF_OPTIONS			1
+#define SVF_MAX_NUM_OF_OPTIONS			5
 	int command_num = 0;
 	int ret = ERROR_OK;
-	long long time_ago;
+	long long time_measure_ms;
+	int time_measure_s, time_measure_m;
 
-	if ((argc < 1) || (argc > (1 + SVF_NUM_OF_OPTIONS)))
+	/* use NULL to indicate a "plain" svf file which accounts for
+	   any additional devices in the scan chain, otherwise the device
+	   that should be affected
+	*/
+	struct jtag_tap *tap = NULL;
+
+	if ((CMD_ARGC < SVF_MIN_NUM_OF_OPTIONS) || (CMD_ARGC > SVF_MAX_NUM_OF_OPTIONS))
 	{
-		command_print(cmd_ctx, "usage: svf <file> [quiet]");
-		return ERROR_FAIL;
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	// parse variant
+	// parse command line
 	svf_quiet = 0;
-	for (unsigned i = 1; i < argc; i++)
+	svf_nil = 0;
+	for (unsigned int i = 0; i < CMD_ARGC; i++)
 	{
-		if (!strcmp(args[i], "quiet"))
+		if (strcmp(CMD_ARGV[i], "-tap") == 0)
+		{
+			tap = jtag_tap_by_string(CMD_ARGV[i+1]);
+			if (!tap)
+			{
+				command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i+1]);
+				return ERROR_FAIL;
+			}
+			i++;
+		}
+		else if ((strcmp(CMD_ARGV[i], "quiet") == 0) || (strcmp(CMD_ARGV[i], "-quiet") == 0))
 		{
 			svf_quiet = 1;
 		}
-		else
+		else if ((strcmp(CMD_ARGV[i], "nil") == 0) || (strcmp(CMD_ARGV[i], "-nil") == 0))
 		{
-			LOG_ERROR("unknown variant for svf: %s", args[i]);
-
+			svf_nil = 1;
+		}
+		else if ((strcmp(CMD_ARGV[i], "progress") == 0) || (strcmp(CMD_ARGV[i], "-progress") == 0))
+		{
+			svf_progress_enabled = 1;
+		}
+		else if ((svf_fd = fopen(CMD_ARGV[i], "r")) == NULL)
+		{
+			int err = errno;
+			command_print(CMD_CTX, "open(\"%s\"): %s", CMD_ARGV[i], strerror(err));
 			// no need to free anything now
-			return ERROR_FAIL;
+			return ERROR_COMMAND_SYNTAX_ERROR;
+		}
+		else
+		{
+			LOG_USER("svf processing file: \"%s\"", CMD_ARGV[i]);
 		}
 	}
 
-	if ((svf_fd = open(args[0], O_RDONLY)) < 0)
+	if (svf_fd == NULL)
 	{
-		command_print(cmd_ctx, "file \"%s\" not found", args[0]);
-
-		// no need to free anything now
-		return ERROR_FAIL;
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	LOG_USER("svf processing file: \"%s\"", args[0]);
-
 	// get time
-	time_ago = timeval_ms();
+	time_measure_ms = timeval_ms();
 
 	// init
 	svf_line_number = 1;
@@ -359,7 +402,7 @@ COMMAND_HANDLER(handle_svf_command)
 
 	svf_buffer_index = 0;
 	// double the buffer size
-	// in case current command cannot be commited, and next command is a bit scan command
+	// in case current command cannot be committed, and next command is a bit scan command
 	// here is 32K bits for this big scan command, it should be enough
 	// buffer will be reallocated if buffer size is not enough
 	svf_tdi_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
@@ -387,12 +430,104 @@ COMMAND_HANDLER(handle_svf_command)
 
 	memcpy(&svf_para, &svf_para_init, sizeof(svf_para));
 
-	// TAP_RESET
-	jtag_add_tlr();
+	if (!svf_nil)
+	{
+		// TAP_RESET
+		jtag_add_tlr();
+	}
+
+	if (tap)
+	{
+		/* Tap is specified, set header/trailer paddings */
+		int header_ir_len = 0, header_dr_len = 0, trailer_ir_len = 0, trailer_dr_len = 0;
+		struct jtag_tap *check_tap;
+
+		svf_tap_is_specified = 1;
+
+		for (check_tap = jtag_all_taps(); check_tap; check_tap = check_tap->next_tap) {
+			if (check_tap->abs_chain_position < tap->abs_chain_position)
+			{
+				//Header
+				header_ir_len += check_tap->ir_length;
+				header_dr_len ++;
+			}
+			else if (check_tap->abs_chain_position > tap->abs_chain_position)
+			{
+				//Trailer
+				trailer_ir_len += check_tap->ir_length;
+				trailer_dr_len ++;
+			}
+		}
+
+		// HDR %d TDI (0)
+		if (ERROR_OK != svf_set_padding(&svf_para.hdr_para, header_dr_len, 0))
+		{
+			LOG_ERROR("failed to set data header");
+			return ERROR_FAIL;
+		}
+
+		// HIR %d TDI (0xFF)
+		if (ERROR_OK != svf_set_padding(&svf_para.hir_para, header_ir_len, 0xFF))
+		{
+			LOG_ERROR("failed to set instruction header");
+			return ERROR_FAIL;
+		}
+
+		// TDR %d TDI (0)
+		if (ERROR_OK != svf_set_padding(&svf_para.tdr_para, trailer_dr_len, 0))
+		{
+			LOG_ERROR("failed to set data trailer");
+			return ERROR_FAIL;
+		}
+
+		// TIR %d TDI (0xFF)
+		if (ERROR_OK != svf_set_padding(&svf_para.tir_para, trailer_ir_len, 0xFF))
+		{
+			LOG_ERROR("failed to set instruction trailer");
+			return ERROR_FAIL;
+		}
 
+	}
+
+	if (svf_progress_enabled)
+	{
+		// Count total lines in file.
+		while ( ! feof (svf_fd) )
+		 {
+		   svf_getline (&svf_command_buffer, &svf_command_buffer_size, svf_fd);
+		   svf_total_lines++;
+		 }
+		rewind(svf_fd);
+	}
 	while (ERROR_OK == svf_read_command_from_file(svf_fd))
 	{
-		if (ERROR_OK != svf_run_command(cmd_ctx, svf_command_buffer))
+		// Log Output
+		if (svf_quiet)
+		{
+			if (svf_progress_enabled)
+			{
+				svf_percentage = ((svf_line_number * 20) / svf_total_lines) * 5;
+				if (svf_last_printed_percentage != svf_percentage)
+				{
+					LOG_USER_N("\r%d%%    ", svf_percentage);
+					svf_last_printed_percentage = svf_percentage;
+				}
+			}
+		}
+		else
+		{
+			if (svf_progress_enabled)
+			{
+				svf_percentage = ((svf_line_number * 20) / svf_total_lines) * 5;
+				LOG_USER_N("%3d%%  %s", svf_percentage, svf_read_line);
+			}
+			else
+			{
+				LOG_USER_N("%s",svf_read_line);
+			}
+		}
+			// Run Command
+		if (ERROR_OK != svf_run_command(CMD_CTX, svf_command_buffer))
 		{
 			LOG_ERROR("fail to run command at line %d", svf_line_number);
 			ret = ERROR_FAIL;
@@ -400,7 +535,8 @@ COMMAND_HANDLER(handle_svf_command)
 		}
 		command_num++;
 	}
-	if (ERROR_OK != jtag_execute_queue())
+
+	if ((!svf_nil) && (ERROR_OK != jtag_execute_queue()))
 	{
 		ret = ERROR_FAIL;
 	}
@@ -410,11 +546,19 @@ COMMAND_HANDLER(handle_svf_command)
 	}
 
 	// print time
-	command_print(cmd_ctx, "%lld ms used", timeval_ms() - time_ago);
+	time_measure_ms = timeval_ms() - time_measure_ms;
+	time_measure_s = time_measure_ms / 1000;
+	time_measure_ms %= 1000;
+	time_measure_m = time_measure_s / 60;
+	time_measure_s %= 60;
+	if (time_measure_ms < 1000)
+	{
+		command_print(CMD_CTX, "\r\nTime used: %dm%ds%lldms ", time_measure_m, time_measure_s, time_measure_ms);
+	}
 
 free_all:
 
-	close(svf_fd);
+	fclose(svf_fd);
 	svf_fd = 0;
 
 	// free buffers
@@ -457,76 +601,143 @@ free_all:
 
 	if (ERROR_OK == ret)
 	{
-		command_print(cmd_ctx, "svf file programmed successfully for %d commands", command_num);
+		command_print(CMD_CTX, "svf file programmed successfully for %d commands", command_num);
 	}
 	else
 	{
-		command_print(cmd_ctx, "svf file programmed failed");
+		command_print(CMD_CTX, "svf file programmed failed");
 	}
 
 	return ret;
 }
 
+static int svf_getline (char **lineptr, size_t *n, FILE *stream)
+{
+#define MIN_CHUNK 16	//Buffer is increased by this size each time as required
+  size_t i = 0;
+
+  if (*lineptr == NULL)
+    {
+      *n = MIN_CHUNK;
+      *lineptr = (char *)malloc (*n);
+      if (!*lineptr)
+        {
+		  return -1;
+        }
+    }
+
+	(*lineptr)[0] = fgetc(stream);
+	while ((*lineptr)[i] != '\n')
+	{
+		(*lineptr)[++i] = fgetc(stream);
+		if (feof(stream))
+		{
+			(*lineptr)[0] = 0;
+			return -1;
+		}
+		if ((i + 2) > *n)
+		{
+			*n += MIN_CHUNK;
+			*lineptr = realloc(*lineptr, *n);
+		}
+	}
+
+	(*lineptr)[++i] = 0;
+
+	return sizeof(*lineptr);
+}
+
 #define SVFP_CMD_INC_CNT			1024
-static int svf_read_command_from_file(int fd)
+static int svf_read_command_from_file(FILE * fd)
 {
-	char ch, *tmp_buffer = NULL;
-	int cmd_pos = 0, cmd_ok = 0, slash = 0, comment = 0;
+	unsigned char ch;
+	int i = 0;
+	size_t cmd_pos = 0;
+	int cmd_ok = 0, slash = 0, comment = 0;
 
-	while (!cmd_ok && (read(fd, &ch, 1) > 0))
+	if (svf_getline (&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
+	{
+		return ERROR_FAIL;
+	}
+	svf_line_number++;
+	ch = svf_read_line[0];
+	while (!cmd_ok && (ch != 0))
 	{
 		switch (ch)
 		{
 		case '!':
 			slash = 0;
-			comment = 1;
+			if (svf_getline (&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
+			{
+				return ERROR_FAIL;
+			}
+			svf_line_number++;
+			i = -1;
 			break;
 		case '/':
 			if (++slash == 2)
 			{
-				comment = 1;
+				slash = 0;
+				if (svf_getline (&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
+				{
+					return ERROR_FAIL;
+				}
+				svf_line_number++;
+				i = -1;
 			}
 			break;
 		case ';':
 			slash = 0;
-			if (!comment)
-			{
-				cmd_ok = 1;
-			}
+			cmd_ok = 1;
 			break;
 		case '\n':
 			svf_line_number++;
+			if (svf_getline (&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
+			{
+				return ERROR_FAIL;
+			}
+			i = -1;
 		case '\r':
 			slash = 0;
 			comment = 0;
-			break;
+			/* Don't save '\r' and '\n' if no data is parsed */
+			if (!cmd_pos)
+				break;
 		default:
-			if (!comment)
+			/* The parsing code currently expects a space
+			 * before parentheses -- "TDI (123)".  Also a
+			 * space afterwards -- "TDI (123) TDO(456)".
+			 * But such spaces are optional... instead of
+			 * parser updates, cope with that by adding the
+			 * spaces as needed.
+			 *
+			 * Ensure there are 3 bytes available, for:
+			 *  - current character
+			 *  - added space.
+			 *  - terminating NUL ('\0')
+			 */
+			if ((cmd_pos + 2) >= svf_command_buffer_size)
 			{
-				if (cmd_pos >= svf_command_buffer_size - 1)
+				svf_command_buffer = realloc(svf_command_buffer, (cmd_pos + 2));
+				if (svf_command_buffer == NULL)
 				{
-					tmp_buffer = (char*)malloc(svf_command_buffer_size + SVFP_CMD_INC_CNT);		// 1 more byte for '\0'
-					if (NULL == tmp_buffer)
-					{
-						LOG_ERROR("not enough memory");
-						return ERROR_FAIL;
-					}
-					if (svf_command_buffer_size > 0)
-					{
-						memcpy(tmp_buffer, svf_command_buffer, svf_command_buffer_size);
-					}
-					if (svf_command_buffer != NULL)
-					{
-						free(svf_command_buffer);
-					}
-					svf_command_buffer = tmp_buffer;
-					svf_command_buffer_size += SVFP_CMD_INC_CNT;
-					tmp_buffer = NULL;
+					LOG_ERROR("not enough memory");
+					return ERROR_FAIL;
 				}
-				svf_command_buffer[cmd_pos++] = (char)toupper(ch);
 			}
+
+			/* insert a space before '(' */
+			if ('(' == ch)
+				svf_command_buffer[cmd_pos++] = ' ';
+
+			svf_command_buffer[cmd_pos++] = (char)toupper(ch);
+
+			/* insert a space after ')' */
+			if (')' == ch)
+				svf_command_buffer[cmd_pos++] = ' ';
 			break;
 		}
+		ch = svf_read_line[++i];
 	}
 
 	if (cmd_ok)
@@ -542,25 +753,30 @@ static int svf_read_command_from_file(int fd)
 
 static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_argu)
 {
-	int pos = 0, num = 0, space_found = 1;
+	int pos = 0, num = 0, space_found = 1, in_bracket = 0;
 
 	while (pos < len)
 	{
 		switch (str[pos])
 		{
-		case '\n':
-		case '\r':
 		case '!':
 		case '/':
 			LOG_ERROR("fail to parse svf command");
 			return ERROR_FAIL;
-			break;
-		case ' ':
-			space_found = 1;
-			str[pos] = '\0';
-			break;
+		case '(':
+			in_bracket = 1;
+			goto parse_char;
+		case ')':
+			in_bracket = 0;
+			goto parse_char;
 		default:
-			if (space_found)
+parse_char:
+			if (!in_bracket && isspace((int) str[pos]))
+			{
+				space_found = 1;
+				str[pos] = '\0';
+			}
+			else if (space_found)
 			{
 				argus[num++] = &str[pos];
 				space_found = 0;
@@ -617,6 +833,19 @@ static int svf_adjust_array_length(uint8_t **arr, int orig_bit_len, int new_bit_
 	return ERROR_OK;
 }
 
+static int svf_set_padding(struct svf_xxr_para *para, int len, unsigned char tdi)
+{
+	int error = ERROR_OK;
+	error |= svf_adjust_array_length(&para->tdi, para->len, len);
+	memset(para->tdi, tdi, (len + 7) >> 3);
+	error |= svf_adjust_array_length(&para->tdo, para->len, len);
+	error |= svf_adjust_array_length(&para->mask, para->len, len);
+	para->len = len;
+	para->data_mask = XXR_TDI;
+
+	return error;
+}
+
 static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_len, int bit_len)
 {
 	int i, str_len = strlen(str), str_hbyte_len = (bit_len + 3) >> 2;
@@ -628,6 +857,7 @@ static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_l
 		return ERROR_FAIL;
 	}
 
+	/* fill from LSB (end of str) to MSB (beginning of str) */
 	for (i = 0; i < str_hbyte_len; i++)
 	{
 		ch = 0;
@@ -635,7 +865,13 @@ static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_l
 		{
 			ch = str[--str_len];
 
-			if (!isblank(ch))
+			/* Skip whitespace.  The SVF specification (rev E) is
+			 * deficient in terms of basic lexical issues like
+			 * where whitespace is allowed.  Long bitstrings may
+			 * require line ends for correctness, since there is
+			 * a hard limit on line length.
+			 */
+			if (!isspace(ch))
 			{
 				if ((ch >= '0') && (ch <= '9'))
 				{
@@ -671,11 +907,12 @@ static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_l
 		}
 	}
 
-	// consume optional leading '0' characters
-	while (str_len > 0 && str[str_len - 1] == '0')
+	/* consume optional leading '0' MSBs or whitespace */
+	while (str_len > 0 && ((str[str_len - 1] == '0')
+				|| isspace((int) str[str_len - 1])))
 		str_len--;
 
-	// check valid
+	/* check validity: we must have consumed everything */
 	if (str_len > 0 || (ch & ~((2 << ((bit_len - 1) % 4)) - 1)) != 0)
 	{
 		LOG_ERROR("value execeeds length");
@@ -687,22 +924,22 @@ static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_l
 
 static int svf_check_tdo(void)
 {
-	int i, len, index;
+	int i, len, index_var;
 
 	for (i = 0; i < svf_check_tdo_para_index; i++)
 	{
-		index = svf_check_tdo_para[i].buffer_offset;
+		index_var = svf_check_tdo_para[i].buffer_offset;
 		len = svf_check_tdo_para[i].bit_len;
 		if ((svf_check_tdo_para[i].enabled)
-			&& buf_cmp_mask(&svf_tdi_buffer[index], &svf_tdo_buffer[index], &svf_mask_buffer[index], len))
+			&& buf_cmp_mask(&svf_tdi_buffer[index_var], &svf_tdo_buffer[index_var], &svf_mask_buffer[index_var], len))
 		{
 			unsigned bitmask;
 			unsigned received, expected, tapmask;
 			bitmask = svf_get_mask_u32(svf_check_tdo_para[i].bit_len);
 
-			memcpy(&received, svf_tdi_buffer + index, sizeof(unsigned));
-			memcpy(&expected, svf_tdo_buffer + index, sizeof(unsigned));
-			memcpy(&tapmask, svf_mask_buffer + index, sizeof(unsigned));
+			memcpy(&received, svf_tdi_buffer + index_var, sizeof(unsigned));
+			memcpy(&expected, svf_tdo_buffer + index_var, sizeof(unsigned));
+			memcpy(&tapmask, svf_mask_buffer + index_var, sizeof(unsigned));
 			LOG_ERROR("tdo check error at line %d",
 					  svf_check_tdo_para[i].line_num);
 			LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
@@ -736,7 +973,7 @@ static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len)
 
 static int svf_execute_tap(void)
 {
-	if (ERROR_OK != jtag_execute_queue())
+	if ((!svf_nil) && (ERROR_OK != jtag_execute_queue()))
 	{
 		return ERROR_FAIL;
 	}
@@ -767,11 +1004,8 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 	struct scan_field field;
 	// for STATE
 	tap_state_t *path = NULL, state;
-
-	if (!svf_quiet)
-	{
-		LOG_USER("%s", svf_command_buffer);
-	}
+	// flag padding commands skipped due to -tap command
+	int padding_command_skipped = 0;
 
 	if (ERROR_OK != svf_parse_cmd_string(cmd_str, strlen(cmd_str), argus, &num_of_argu))
 	{
@@ -783,7 +1017,7 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 	 */
 
 	command = svf_find_string_in_array(argus[0],
-			(char **)svf_command_name, DIM(svf_command_name));
+			(char **)svf_command_name, ARRAY_SIZE(svf_command_name));
 	switch (command)
 	{
 	case ENDDR:
@@ -844,21 +1078,41 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 			// TODO: set jtag speed to
 			if (svf_para.frequency > 0)
 			{
-				command_run_linef(cmd_ctx, "jtag_khz %d", (int)svf_para.frequency / 1000);
+				command_run_linef(cmd_ctx, "adapter_khz %d", (int)svf_para.frequency / 1000);
 				LOG_DEBUG("\tfrequency = %f", svf_para.frequency);
 			}
 		}
 		break;
 	case HDR:
+		if (svf_tap_is_specified)
+		{
+			padding_command_skipped = 1;
+			break;
+		}
 		xxr_para_tmp = &svf_para.hdr_para;
 		goto XXR_common;
 	case HIR:
+		if (svf_tap_is_specified)
+		{
+			padding_command_skipped = 1;
+			break;
+		}
 		xxr_para_tmp = &svf_para.hir_para;
 		goto XXR_common;
 	case TDR:
+		if (svf_tap_is_specified)
+		{
+			padding_command_skipped = 1;
+			break;
+		}
 		xxr_para_tmp = &svf_para.tdr_para;
 		goto XXR_common;
 	case TIR:
+		if (svf_tap_is_specified)
+		{
+			padding_command_skipped = 1;
+			break;
+		}
 		xxr_para_tmp = &svf_para.tir_para;
 		goto XXR_common;
 	case SDR:
@@ -1044,12 +1298,14 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 			{
 				svf_add_check_para(0, svf_buffer_index, i);
 			}
-			field.tap = tap;
 			field.num_bits = i;
 			field.out_value = &svf_tdi_buffer[svf_buffer_index];
 			field.in_value = &svf_tdi_buffer[svf_buffer_index];
-			/* NOTE:  doesn't use SVF-specified state paths */
-			jtag_add_plain_dr_scan(1, &field, svf_para.dr_end_state);
+			if (!svf_nil)
+			{
+				/* NOTE:  doesn't use SVF-specified state paths */
+				jtag_add_plain_dr_scan(field.num_bits, field.out_value, field.in_value, svf_para.dr_end_state);
+			}
 
 			svf_buffer_index += (i + 7) >> 3;
 		}
@@ -1140,12 +1396,15 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 			{
 				svf_add_check_para(0, svf_buffer_index, i);
 			}
-			field.tap = tap;
 			field.num_bits = i;
 			field.out_value = &svf_tdi_buffer[svf_buffer_index];
 			field.in_value = &svf_tdi_buffer[svf_buffer_index];
-			/* NOTE:  doesn't use SVF-specified state paths */
-			jtag_add_plain_ir_scan(1, &field, svf_para.ir_end_state);
+			if (!svf_nil)
+			{
+				/* NOTE:  doesn't use SVF-specified state paths */
+				jtag_add_plain_ir_scan(field.num_bits, field.out_value, field.in_value,
+						svf_para.ir_end_state);
+			}
 
 			svf_buffer_index += (i + 7) >> 3;
 		}
@@ -1242,47 +1501,48 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 			}
 			i += 2;
 		}
-		// calculate run_count
-		if ((0 == run_count) && (min_time > 0))
-		{
-			run_count = min_time * svf_para.frequency;
-		}
+
 		// all parameter should be parsed
 		if (i == num_of_argu)
 		{
-			if (run_count > 0)
-			{
-				// run_state and end_state is checked to be stable state
-				// TODO: do runtest
 #if 1
-				/* FIXME handle statemove failures */
-				int retval;
+			/* FIXME handle statemove failures */
+			int retval;
+			uint32_t min_usec = 1000000 * min_time;
 
-				// enter into run_state if necessary
-				if (cmd_queue_cur_state != svf_para.runtest_run_state)
-				{
-					retval = svf_add_statemove(svf_para.runtest_run_state);
-				}
+			// enter into run_state if necessary
+			if (cmd_queue_cur_state != svf_para.runtest_run_state)
+			{
+				retval = svf_add_statemove(svf_para.runtest_run_state);
+			}
 
-				// call jtag_add_clocks
-				jtag_add_clocks(run_count);
+			// add clocks and/or min wait
+			if (run_count > 0) {
+				if (!svf_nil)
+					jtag_add_clocks(run_count);
+			}
 
-				// move to end_state if necessary
-				if (svf_para.runtest_end_state != svf_para.runtest_run_state)
-				{
-					retval = svf_add_statemove(svf_para.runtest_end_state);
-				}
+			if (min_usec > 0) {
+				if (!svf_nil)
+					jtag_add_sleep(min_usec);
+			}
+
+			// move to end_state if necessary
+			if (svf_para.runtest_end_state != svf_para.runtest_run_state)
+			{
+				retval = svf_add_statemove(svf_para.runtest_end_state);
+			}
 #else
-				if (svf_para.runtest_run_state != TAP_IDLE)
-				{
-					LOG_ERROR("cannot runtest in %s state",
-						tap_state_name(svf_para.runtest_run_state));
-					return ERROR_FAIL;
-				}
+			if (svf_para.runtest_run_state != TAP_IDLE)
+			{
+				LOG_ERROR("cannot runtest in %s state",
+					tap_state_name(svf_para.runtest_run_state));
+				return ERROR_FAIL;
+			}
 
+			if (!svf_nil)
 				jtag_add_runtest(run_count, svf_para.runtest_end_state);
 #endif
-			}
 		}
 		else
 		{
@@ -1324,9 +1584,11 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 					/* FIXME last state MUST be stable! */
 					if (i > 0)
 					{
-						jtag_add_pathmove(i, path);
+						if (!svf_nil)
+							jtag_add_pathmove(i, path);
 					}
-					jtag_add_tlr();
+					if (!svf_nil)
+						jtag_add_tlr();
 					num_of_argu -= i + 1;
 					i = -1;
 				}
@@ -1337,7 +1599,8 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 				if (svf_tap_state_is_stable(path[num_of_argu - 1]))
 				{
 					// last state MUST be stable state
-					jtag_add_pathmove(num_of_argu, path);
+					if (!svf_nil)
+						jtag_add_pathmove(num_of_argu, path);
 					LOG_DEBUG("\tmove to %s by path_move",
 						tap_state_name(path[num_of_argu - 1]));
 				}
@@ -1350,12 +1613,9 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 					return ERROR_FAIL;
 				}
 			}
-			// no need to keep this memory, in jtag_add_pathmove, path will be duplicated
-			if (NULL != path)
-			{
-				free(path);
-				path = NULL;
-			}
+
+			free(path);
+			path = NULL;
 		}
 		else
 		{
@@ -1391,15 +1651,17 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 			}
 			i_tmp = svf_find_string_in_array(argus[1],
 					(char **)svf_trst_mode_name,
-					DIM(svf_trst_mode_name));
+					ARRAY_SIZE(svf_trst_mode_name));
 			switch (i_tmp)
 			{
 			case TRST_ON:
-				jtag_add_reset(1, 0);
+				if (!svf_nil)
+					jtag_add_reset(1, 0);
 				break;
 			case TRST_Z:
 			case TRST_OFF:
-				jtag_add_reset(0, 0);
+				if (!svf_nil)
+					jtag_add_reset(0, 0);
 				break;
 			case TRST_ABSENT:
 				break;
@@ -1422,6 +1684,14 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 		break;
 	}
 
+	if (!svf_quiet)
+	{
+		if (padding_command_skipped)
+		{
+			LOG_USER("(Above Padding command skipped, as per -tap argument)");
+		}
+	}
+
 	if (debug_level >= LOG_LVL_DEBUG)
 	{
 		// for convenient debugging, execute tap if possible
@@ -1460,11 +1730,18 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 	return ERROR_OK;
 }
 
+static const struct command_registration svf_command_handlers[] = {
+	{
+		.name = "svf",
+		.handler = handle_svf_command,
+		.mode = COMMAND_EXEC,
+		.help = "Runs a SVF file.",
+		.usage = "svf [-tap device.tap] <file> [quiet] [nil] [progress]",
+	},
+	COMMAND_REGISTRATION_DONE
+};
+
 int svf_register_commands(struct command_context *cmd_ctx)
 {
-	register_command(cmd_ctx, NULL, "svf",
-			&handle_svf_command, COMMAND_EXEC,
-			"run svf <file>");
-
-	return ERROR_OK;
+	return register_commands(cmd_ctx, NULL, svf_command_handlers);
 }