util: improve uartupdatetool (UUT) mechanism

The original UUT mechanism has the limitation that the image size cannot
exceed the code RAM size. Hence, it only allows to flash the EC firmware
by programming RO and RW images seperately.

In this CL, we introduce the "--auto" flag in uartupdattool.
It will divide the firmware into segments (4K bytes) and program
the segments one by one.
It also simplifies the function flash_npcx_uut() in flash_ec because
some actions are moved into the uartupdatetool with auto flag enabled.

BRANCH=none
BUG=none
TEST=No build errors for make buildall.
TEST=
------------------------------------------------------------------------
1. Connect the servo connector (J24) on npcx7 EVB to servo board v2 via
flex cable.
2. Manually turn the switch SW1.6 to "ON" on npcx7 EVB.
3. Reset ec by issuing Power-Up or VCC1_RST reset.
4. Manually turn the switch SW1.6 to "OFF" on npcx7 EVB.
5. Move npcx7_evb from array BOARDS_NPCX_7M7X_JTAG to BOARDS_NPCX_UUT in
flash_ec.
6. "./util/flash_ec --board=npcx7_evb" or
   "./util/flash_ec --board=npcx7_evb --ro"
(Note: this line in flash_ec must be removed in step 6:
https://chromium.googlesource.com/chromiumos/platform/ec/+/master/util/flash_ec#961)

Change-Id: Ifdb6a40ef88c6a9fb435169e158fd615100237cf
Signed-off-by: CHLin <CHLIN56@nuvoton.com>
Reviewed-on: https://chromium-review.googlesource.com/1043825
Commit-Ready: CH Lin <chlin56@nuvoton.com>
Tested-by: CH Lin <chlin56@nuvoton.com>
Reviewed-by: Vincent Palatin <vpalatin@chromium.org>

4 files changed, 261 insertions, 135 deletions

diff --git a/util/flash_ec b/util/flash_ec
index 593a4ede1e..2260b53674 100755
--- a/util/flash_ec
+++ b/util/flash_ec
@@ -447,7 +447,11 @@ fi
 
 LOCAL_BUILD=
 if [[ -n "${EC_DIR}" ]]; then
-	LOCAL_BUILD="${EC_DIR}/build/${BOARD}/${EC_FILE}"
+	if [ "${FLAGS_ro}" = ${FLAGS_TRUE} ] ; then
+		LOCAL_BUILD="${EC_DIR}/build/${BOARD}/RO/${EC_FILE}"
+	else
+		LOCAL_BUILD="${EC_DIR}/build/${BOARD}/${EC_FILE}"
+	fi
 fi
 
 # Get baseboard from build system if present
@@ -953,18 +957,9 @@ function flash_npcx_uut() {
 
 	BUILD_PATH="${EC_DIR}/build/${BOARD}"
 	MONITOR_PATH="${BUILD_PATH}/chip/npcx/spiflashfw"
-	IMG_RO="${BUILD_PATH}/RO/ec.RO.flat"
-	IMG_RW="${BUILD_PATH}/RW/ec.RW.bin"
 	MON="${MONITOR_PATH}/npcx_monitor.bin"
-	MON_HDR_RO="${MONITOR_PATH}/monitor_hdr_ro.bin"
-	MON_HDR_RW="${MONITOR_PATH}/monitor_hdr_rw.bin"
-	# The start address to restore monitor header binary
-	MON_HDR_ADDR="0x200C3000"
 	# The start address to restore monitor firmware binary
 	MON_ADDR="0x200C3020"
-	# Read the address where the EC image should be loaded from monitor header.
-	# Default: It is equilvalant to the beginning of code RAM address.
-	EC_IMG_ADDR="0x"$(xxd -e ${MON_HDR_RO} | cut -d' ' -f4)
 
 	if [ ! -x "$NPCX_UUT" ]; then
 		die "no NPCX UART Update Tool found."
@@ -987,45 +982,11 @@ function flash_npcx_uut() {
 
 	# Remove the prefix "/dev/" because uartupdatetool will add it.
 	EC_UART=${EC_UART#/dev/}
-	MON_PARAMS="--port ${EC_UART} --baudrate 115200"
-
-	# Read the RO image size
-	EC_IMG_SIZE=$(printf "%08X" $(stat -c "%s" ${IMG_RO}))
-	# Covert RO image size to little endian
-	EC_IMG_SIZE_LE=${EC_IMG_SIZE:6:2}${EC_IMG_SIZE:4:2}${EC_IMG_SIZE:2:2}${EC_IMG_SIZE:0:2}
-	# Replace the filed of image size in monitor header with the actual RO image size.
-	T=/tmp/mon_hdr_ro.$$
-	xxd -g4 ${MON_HDR_RO} | awk -v s="$EC_IMG_SIZE_LE" 'NR==1 {$3=s}1' | xxd -r > ${T}
-
-	info "Start to flash RO image.."
-	# Start to program EC RO image
-	# Load monitor header binary to address 0x200C3000
-	${NPCX_UUT} ${MON_PARAMS} --opr wr --addr ${MON_HDR_ADDR} --file ${T}
-	# Load monitor binary to address 0x200C3020
-	${NPCX_UUT} ${MON_PARAMS} --opr wr --addr ${MON_ADDR} --file ${MON}
-	# Load RO image to Code RAM range.
-	${NPCX_UUT} ${MON_PARAMS} --opr wr --addr ${EC_IMG_ADDR} --file ${IMG_RO}
-	# Execute the monitor to program RO image on SPI flash
-	${NPCX_UUT} ${MON_PARAMS} --opr call --addr ${MON_ADDR}
-
-	# Read the RW image size
-	EC_IMG_SIZE=$(printf "%08X" $(stat -c "%s" ${IMG_RW}))
-	# Covert RW image size to little endian
-	EC_IMG_SIZE_LE=${EC_IMG_SIZE:6:2}${EC_IMG_SIZE:4:2}${EC_IMG_SIZE:2:2}${EC_IMG_SIZE:0:2}
-	# Replace the filed of image size in monitor header with the actual RW image size.
-	T=/tmp/mon_hdr_rw.$$
-	xxd -g4 ${MON_HDR_RW} | awk -v s="$EC_IMG_SIZE_LE" 'NR==1 {$3=s}1' | xxd -r > ${T}
-
-	info "Start to flash RW image.."
-	# Start to program EC RW image
-	# Load monitor header binary to address 0x200C3000
-	${NPCX_UUT} ${MON_PARAMS} --opr wr --addr ${MON_HDR_ADDR} --file ${T}
+	UUT_PARAMS="--port ${EC_UART} --baudrate 115200"
+
 	# Load monitor binary to address 0x200C3020
-	${NPCX_UUT} ${MON_PARAMS} --opr wr --addr ${MON_ADDR} --file ${MON}
-	# Load RW image to Code RAM range.
-	${NPCX_UUT} ${MON_PARAMS} --opr wr --addr ${EC_IMG_ADDR} --file ${IMG_RW}
-	# Execute the monitor to program RW image on SPI flash
-	${NPCX_UUT} ${MON_PARAMS} --opr call --addr ${MON_ADDR}
+	${NPCX_UUT} ${UUT_PARAMS} --opr wr --addr ${MON_ADDR} --file ${MON}
+	${NPCX_UUT} ${UUT_PARAMS} --auto --offset ${FLAGS_offset} --file ${IMG}
 
 	# Reconnect the EC-3PO interpreter to the UART.
 	dut_control ${MCU}_ec3po_interp_connect:on || \
diff --git a/util/uut/main.c b/util/uut/main.c
index 4f54c62f29..251ee1bb4a 100644
--- a/util/uut/main.c
+++ b/util/uut/main.c
@@ -4,6 +4,7 @@
  * found in the LICENSE file.
  */
 
+#include <errno.h>
 #include <getopt.h>
 #include <stdarg.h>
 #include <stdint.h>
@@ -30,7 +31,18 @@
 #define DEFAULT_BAUD_RATE 115200
 #define DEFAULT_PORT_NAME "ttyS0"
 #define DEFAULT_DEV_NUM 0
-
+#define DEFAULT_FLASH_OFFSET 0
+
+/* The magic number in monitor header */
+#define MONITOR_HDR_TAG        0xA5075001
+/* The location of monitor header */
+#define MONITOR_HDR_ADDR       0x200C3000
+/* The start address of the monitor little firmware to execute */
+#define MONITOR_ADDR           0x200C3020
+/* The start address to store the firmware segment to be programmed */
+#define FIRMWARE_START_ADDR    0x10090000
+/* Divide the ec firmware image into 4K byte */
+#define FIRMWARE_SEGMENT       0x1000
 /*---------------------------------------------------------------------------
  * Global variables
  *---------------------------------------------------------------------------
@@ -54,6 +66,8 @@ static char addr_str[MAX_PARAM_SIZE];
 static char size_str[MAX_PARAM_SIZE];
 static uint32_t baudrate;
 static uint32_t dev_num;
+static uint32_t flash_offset;
+static bool auto_mode;
 
 /*---------------------------------------------------------------------------
  * Functions prototypes
@@ -66,7 +80,7 @@ static uint32_t param_get_file_size(const char *file_name);
 static uint32_t param_get_str_size(char *string);
 static void main_print_version(void);
 static void tool_usage(void);
-static void exit_uart_app(uint32_t exit_status);
+static void exit_uart_app(int32_t exit_status);
 
 enum EXIT_CODE {
 	EC_OK = 0x00,
@@ -86,6 +100,108 @@ enum EXIT_CODE {
  */
 
 /*---------------------------------------------------------------------------
+ * Function:	image_auto_write
+ *
+ * Parameters:    offset - The start address of the flash to write the firmware
+ *                         to.
+ *                buffer - The buffer holds data of the firmware.
+ *                file_size - the size to be programmed.
+ * Returns:       1 for a successful operation, 0 otherwise.
+ * Side effects:
+ * Description:
+ *               Divide the firmware to segments and program them one by one.
+ *---------------------------------------------------------------------------
+ */
+static bool image_auto_write(uint32_t offset, uint8_t *buffer,
+				uint32_t file_size)
+{
+	uint32_t data_buf[4];
+	uint32_t addr, chunk_remain, file_seg, flash_index, seg;
+	uint32_t count, percent, total;
+
+	flash_index = offset;
+	/* Monitor tag */
+	data_buf[0] = MONITOR_HDR_TAG;
+	/* Where the source(RAM) address the firmware stored. */
+	data_buf[2] = FIRMWARE_START_ADDR;
+
+	file_seg = file_size;
+	total = 0;
+	while (file_seg) {
+		seg = (file_seg > FIRMWARE_SEGMENT) ?
+					FIRMWARE_SEGMENT : file_seg;
+		chunk_remain = seg;
+		addr = FIRMWARE_START_ADDR;
+		/* the size to be programmed */
+		data_buf[1] = seg;
+		/*
+		 * The offset of the flash where the segment to be programmed.
+		 */
+		data_buf[3] = flash_index;
+		/* Write the monitor header to RAM */
+		opr_write_chunk((uint8_t *)data_buf, MONITOR_HDR_ADDR, 16);
+		while (chunk_remain) {
+			count = (chunk_remain > MAX_RW_DATA_SIZE) ?
+						MAX_RW_DATA_SIZE : chunk_remain;
+			if (opr_write_chunk(buffer, addr, count) != true)
+				return false;
+
+			addr += count;
+			buffer += count;
+			chunk_remain -= count;
+			total += count;
+			percent = total * 100 / file_size;
+			printf("\r[%d%%] %d/%d", percent, total, file_size);
+		}
+		fflush(stdout);
+		if (opr_execute_return(MONITOR_ADDR) != true)
+			return false;
+		file_seg -= seg;
+		flash_index += seg;
+	}
+	printf("\n");
+	return true;
+}
+
+/*---------------------------------------------------------------------------
+ * Function:	read_input_file
+ *
+ * Parameters:    size - The size of input file.
+ *                file_name - The name if input file.
+ * Returns:       The address of the buffer allocated to stroe file content.
+ * Side effects:
+ * Description:
+ *               Read the file content into an allocated buffer.
+ *---------------------------------------------------------------------------
+ */
+static uint8_t *read_input_file(uint32_t size, const char *file_name)
+{
+	uint8_t *buffer;
+	FILE *input_fp;
+
+	buffer = malloc(size);
+	if (!buffer) {
+		fprintf(stderr, "Cannot allocate %d bytes\n", size);
+		return NULL;
+	}
+	input_fp = fopen(file_name, "r");
+	if (!input_fp) {
+		display_color_msg(FAIL,
+			"ERROR: cannot open file %s\n", file_name);
+		free(buffer);
+		return NULL;
+	}
+	if (fread(buffer, size, 1, input_fp) != 1) {
+		fprintf(stderr, "Cannot read %s\n", file_name);
+		fclose(input_fp);
+		free(buffer);
+		return NULL;
+	}
+	fclose(input_fp);
+	return buffer;
+}
+
+/*---------------------------------------------------------------------------
  * Function:	main
  *
  * Parameters:		argc - Argument Count.
@@ -102,7 +218,9 @@ int main(int argc, char *argv[])
 	char aux_buf[MAX_FILE_NAME_SIZE];
 	uint32_t size = 0;
 	uint32_t addr = 0;
+	uint32_t strip_size;
 	enum sync_result sr;
+	uint8_t *buffer;
 
 	if (argc <= 1)
 		exit(EC_UNSUPPORTED_CMD_ERR);
@@ -111,9 +229,11 @@ int main(int argc, char *argv[])
 	strncpy(port_name, DEFAULT_PORT_NAME, sizeof(port_name));
 	baudrate = DEFAULT_BAUD_RATE;
 	dev_num = DEFAULT_DEV_NUM;
+	flash_offset = DEFAULT_FLASH_OFFSET;
 	opr_name[0] = '\0';
 	verbose = true;
 	console = false;
+	auto_mode = false;
 
 	param_parse_cmd_line(argc, argv);
 
@@ -145,29 +265,59 @@ int main(int argc, char *argv[])
 		exit_uart_app(EC_SYNC_ERR);
 	}
 
+	if (auto_mode) {
+		size = param_get_file_size(file_name);
+		if (size == 0)
+			exit_uart_app(EC_FILE_ERR);
+
+		buffer = read_input_file(size, file_name);
+		if (!buffer)
+			exit_uart_app(EC_FILE_ERR);
+
+		/* Ignore the trailing white space to speed up writing */
+		strip_size = size;
+		while ((strip_size > 0) && (buffer[strip_size-1] == 0xFF))
+			strip_size--;
+
+		printf("Write file %s at %d with %d bytes\n",
+					file_name, flash_offset, strip_size);
+		if (image_auto_write(flash_offset, buffer, strip_size)) {
+			printf("Flash Done.\n");
+			free(buffer);
+			exit_uart_app(EC_OK);
+		}
+		free(buffer);
+		exit_uart_app(-1);
+	}
+
 	param_check_opr_num(opr_name);
 
 	/* Write buffer data to chosen address */
 	if (strcmp(opr_name, OPR_WRITE_MEM) == 0) {
 		addr = strtoul(addr_str, &stop_str, 0);
 
-		/*
-		 * Copy the input string to an auxiliary buffer, since string
-		 * is altered by param_get_str_size
-		 */
-		memcpy(aux_buf, file_name, sizeof(file_name));
-
-		/* Retrieve input size */
-		if (console)
-			size = param_get_str_size(aux_buf);
-		else
+		if (console) {
+			/*
+			 * Copy the input string to an auxiliary buffer, since
+			 * string is altered by param_get_str_size
+			 */
+			memcpy(aux_buf, file_name, sizeof(file_name));
+			/* Retrieve input size */
+			size = param_get_str_size(file_name);
+			/* Ensure non-zero size */
+			if (size == 0)
+				exit_uart_app(EC_FILE_ERR);
+			opr_write_mem(aux_buf, addr, size);
+		} else {
 			size = param_get_file_size(file_name);
-
-		/* Ensure non-zero size */
-		if (size == 0)
-			exit_uart_app(EC_FILE_ERR);
-
-		opr_write_mem(file_name, addr, size);
+			if (size == 0)
+				exit_uart_app(EC_FILE_ERR);
+			buffer = read_input_file(size, file_name);
+			if (!buffer)
+				exit_uart_app(EC_FILE_ERR);
+			opr_write_mem(buffer, addr, size);
+			free(buffer);
+		}
 	} else if (strcmp(opr_name, OPR_READ_MEM) == 0) {
 		/* Read data to chosen address */
 
@@ -213,16 +363,18 @@ static const struct option long_opts[] = {
 	{"help",     0, 0, 'h'},
 	{"quiet",    0, 0, 'q'},
 	{"console",  0, 0, 'c'},
+	{"auto",     0, 0, 'A'},
 	{"baudrate", 1, 0, 'b'},
 	{"opr",      1, 0, 'o'},
 	{"port",     1, 0, 'p'},
 	{"file",     1, 0, 'f'},
 	{"addr",     1, 0, 'a'},
 	{"size",     1, 0, 's'},
+	{"offset",   1, 0, 'O'},
 	{NULL,       0, 0, 0}
 };
 
-static char *short_opts = "vhqcb:o:p:f:a:s:?";
+static char *short_opts = "vhqcAb:o:p:f:a:s:O:?";
 
 static void param_parse_cmd_line(int argc, char *argv[])
 {
@@ -246,6 +398,9 @@ static void param_parse_cmd_line(int argc, char *argv[])
 		case 'c':
 			console = true;
 			break;
+		case 'A':
+			auto_mode = true;
+			break;
 		case 'b':
 			if (sscanf(optarg, "%du", &baudrate) == 0)
 				exit(EC_BAUDRATE_ERR);
@@ -270,6 +425,9 @@ static void param_parse_cmd_line(int argc, char *argv[])
 			strncpy(size_str, optarg, sizeof(size_str));
 			size_str[sizeof(size_str)-1] = '\0';
 			break;
+		case 'O':
+			flash_offset = strtol(optarg, NULL, 0);
+			break;
 		}
 	}
 }
@@ -376,22 +534,25 @@ static void tool_usage(void)
 {
 	printf("%s version %s\n\n", tool_name, tool_version);
 	printf("General switches:\n");
-	printf("      --version         - Print version\n");
-	printf("      --help            - Help menu\n");
-	printf("      --quiet           - Suppress verbose mode (default is "
+	printf("  -v, --version        - Print version\n");
+	printf("  -h, --help           - Help menu\n");
+	printf("  -q, --quiet          - Suppress verbose mode (default is "
 	       "verbose ON)\n");
-	printf("      --console         - Print data to console (default is "
+	printf("  -c, --console        - Print data to console (default is "
 	       "print to file)\n");
-	printf("      --port <name>     - Serial port name (default is %s)\n",
+	printf("  -p, --port <name>    - Serial port name (default is %s)\n",
 		DEFAULT_PORT_NAME);
-	printf("      --baudrate <num>  - COM Port baud-rate (default is %d)\n",
+	printf("  -b, --baudrate <num> - COM Port baud-rate (default is %d)\n",
 		DEFAULT_BAUD_RATE);
+	printf("  -A, --auto           - Enable auto mode. (default is off)\n");
+	printf("  -O, --offset <num>   - With --auto, assign the offset of");
+	printf(" flash where the image to be written.\n");
 	printf("\n");
 	printf("Operation specific switches:\n");
-	printf("      --opr   <name>    - Operation number (see list below)\n");
-	printf("      --file  <name>    - Input/output file name\n");
-	printf("      --addr  <num>     - Start memory address\n");
-	printf("      --size  <num>     - Size of data to read\n");
+	printf("  -o, --opr   <name>   - Operation number (see list below)\n");
+	printf("  -f, --file  <name>   - Input/output file name\n");
+	printf("  -a, --addr  <num>    - Start memory address\n");
+	printf("  -s, --size  <num>    - Size of data to read\n");
 	printf("\n");
 }
 
@@ -420,7 +581,7 @@ static void main_print_version(void)
  *		Exit "nicely" the application.
  *---------------------------------------------------------------------------
  */
-static void exit_uart_app(uint32_t exit_status)
+static void exit_uart_app(int32_t exit_status)
 {
 	if (opr_close_port() != true)
 		display_color_msg(FAIL, "ERROR: Port close failed.\n");
diff --git a/util/uut/opr.c b/util/uut/opr.c
index 4c79f0ba9b..27f4c3463d 100644
--- a/util/uut/opr.c
+++ b/util/uut/opr.c
@@ -129,6 +129,34 @@ bool opr_open_port(const char *port_name, struct comport_fields port_cfg)
 }
 
 /*----------------------------------------------------------------------------
+ * Function:	opr_write_chunk
+ *
+ * Parameters:
+ *      buffer  - Input data buffer.
+ *      addr    - Memory address to write to.
+ *      size    - Data size to write.
+ * Returns: true if successful, false in the case of an error.
+ * Side effects:
+ * Description:
+ *   Write data to RAM, starting from the given  address (addr).
+ *   Data size is limited to the max chunk size (256 bytes).
+ *---------------------------------------------------------------------------
+ */
+bool opr_write_chunk(uint8_t *buffer, uint32_t addr, uint32_t size)
+{
+	struct command_node wr_cmd_buf;
+
+	if (size > MAX_RW_DATA_SIZE) {
+		display_color_msg(FAIL,
+			"ERROR: Block cannot exceed %d\n", MAX_RW_DATA_SIZE);
+	}
+	/* Initialize response size */
+	wr_cmd_buf.resp_size = 1;
+	cmd_create_write(addr, size, buffer,
+			wr_cmd_buf.cmd, &wr_cmd_buf.cmd_size);
+	return opr_send_cmds(&wr_cmd_buf, 1);
+}
+/*----------------------------------------------------------------------------
  * Function:	opr_write_mem
  *
  * Parameters:	input	- Input (file-name/console), containing data to write.
@@ -145,12 +173,11 @@ bool opr_open_port(const char *port_name, struct comport_fields port_cfg)
  *	(console mode).
  *---------------------------------------------------------------------------
  */
-void opr_write_mem(char *input, uint32_t addr, uint32_t size)
+void opr_write_mem(uint8_t *buffer, uint32_t addr, uint32_t size)
 {
-	FILE *input_file_id = NULL;
 	uint32_t cur_addr = addr;
 	uint8_t data_buf[256];
-	uint32_t write_size;
+	uint32_t write_size, size_remain;
 	uint32_t cmd_idx = 1;
 	char seps[] = " ";
 	char *token = NULL;
@@ -158,17 +185,6 @@ void opr_write_mem(char *input, uint32_t addr, uint32_t size)
 	uint32_t block_size = (console) ? sizeof(uint32_t) : MAX_RW_DATA_SIZE;
 	struct command_node wr_cmd_buf;
 
-	if (!console) {
-		input_file_id = fopen(input, "rb");
-
-		if (input_file_id == NULL) {
-			display_color_msg(FAIL,
-				"ERROR: could not open input file [%s]\n",
-				input);
-			return;
-		}
-	}
-
 	/* Initialize response size */
 	wr_cmd_buf.resp_size = 1;
 
@@ -177,15 +193,12 @@ void opr_write_mem(char *input, uint32_t addr, uint32_t size)
 
 	/* Read first token from string */
 	if (console)
-		token = strtok(input, seps);
+		token = strtok(buffer, seps);
 
+	size_remain = size;
 	/* Main write loop */
 	while (true) {
 		if (console) {
-			/* Check if last token in string is reached */
-			if (token == NULL)
-				break;
-
 			/*
 			 * Invert token to double-word and insert the value to
 			 * data buffer
@@ -193,48 +206,32 @@ void opr_write_mem(char *input, uint32_t addr, uint32_t size)
 			(*(uint32_t *)data_buf) =
 				strtoul(token, &stop_str, BASE_HEXADECIMAL);
 
-			/* Block size is fixed to a double-word */
-			write_size = sizeof(uint32_t);
-
 			/* Prepare the next iteration */
 			token = strtok(NULL, seps);
+		}
+		write_size = (size_remain > block_size) ?
+					block_size : size_remain;
+		if (console) {
+			cmd_create_write(cur_addr, write_size, data_buf,
+					wr_cmd_buf.cmd, &wr_cmd_buf.cmd_size);
 		} else {
-			/* Check if end of file is reached */
-			if (feof(input_file_id))
-				break;
-
-			/* Read from file into data buffer */
-			write_size = (uint32_t)fread(data_buf, 1, block_size,
-						input_file_id);
-
-			/*
-			 * In case we read the exact size of the file (e.g.,
-			 * 256 bytes), feof will return 0 because, even though
-			 * the file pointer is at the end of the file, we have
-			 * not attempted to read beyond the end.
-			 * Only after trying to read additional byte will feof
-			 * return a nonzero value
-			 */
-			if (write_size == 0)
-				break;
+			cmd_create_write(cur_addr, write_size, buffer,
+					wr_cmd_buf.cmd, &wr_cmd_buf.cmd_size);
+			buffer += write_size;
 		}
-
-		cmd_create_write(cur_addr, write_size, data_buf, wr_cmd_buf.cmd,
-			&wr_cmd_buf.cmd_size);
 		if (opr_send_cmds(&wr_cmd_buf, 1) != true)
 			break;
 
 		cmd_disp_write(resp_buf, write_size, cmd_idx,
 			((size + (block_size - 1)) / block_size));
-
-		cur_addr += block_size;
+		cur_addr += write_size;
+		size_remain -= write_size;
 		cmd_idx++;
+		if (size_remain == 0)
+			break;
 	}
 
 	DISPLAY_MSG(("\n"));
-
-	if (!console)
-		fclose(input_file_id);
 }
 
 /*----------------------------------------------------------------------------
@@ -331,23 +328,29 @@ void opr_execute_exit(uint32_t addr)
  * Function:	opr_execute_return
  *
  * Parameters:	addr - Start address to execute from.
- * Returns:	none.
+ * Returns:	true if successful, false in the case of an error.
  * Side effects:
  * Description:
- *	Execute code starting from a given address.
- *	Memory address may be in Flash (SPI), DRAM (DDR) or SRAM.
- *	The executed code should return with the execution result.
+ *  Execute code starting from the given address and then check the result.
+ *  The executed code should return with the execution result.
  *---------------------------------------------------------------------------
  */
-void opr_execute_return(uint32_t addr)
+bool opr_execute_return(uint32_t addr)
 {
 	uint32_t cmd_num;
 
 	cmd_build_exec_ret(addr, cmd_buf, &cmd_num);
 	if (opr_send_cmds(cmd_buf, cmd_num) != true)
-		return;
+		return false;
 
-	cmd_disp_exec_ret(resp_buf);
+	/*
+	 * Check the response command code is UFPP_FCALL_RSLT_CMD and
+	 * the return value from monitor is 0x03. (program finish and verify ok)
+	 */
+	if (resp_buf[1] != (uint8_t)(UFPP_FCALL_RSLT_CMD)
+					|| resp_buf[2] != 0x03)
+		return false;
+	return true;
 }
 
 /*----------------------------------------------------------------------------
diff --git a/util/uut/opr.h b/util/uut/opr.h
index 21e05b7daf..f3d630ceb4 100644
--- a/util/uut/opr.h
+++ b/util/uut/opr.h
@@ -48,10 +48,11 @@ extern struct comport_fields port_cfg;
 void opr_usage(void);
 bool opr_close_port(void);
 bool opr_open_port(const char *port_name, struct comport_fields port_cfg);
-void opr_write_mem(char *input, uint32_t addr, uint32_t size);
+bool opr_write_chunk(uint8_t *buffer, uint32_t addr, uint32_t size);
+void opr_write_mem(uint8_t *buffer, uint32_t addr, uint32_t size);
 void opr_read_mem(char *output, uint32_t addr, uint32_t size);
 void opr_execute_exit(uint32_t addr);
-void opr_execute_return(uint32_t addr);
+bool opr_execute_return(uint32_t addr);
 bool opr_scan_baudrate(void);
 enum sync_result opr_check_sync(uint32_t baudrate);
 #endif /* __UTIL_UUT_OPR_H */