From d0581f881c4072ef0ac453167a98dc3bc0d87d86 Mon Sep 17 00:00:00 2001
From: Leo C <erbl259-lmu@yahoo.de>
Date: Wed, 20 Aug 2014 14:01:11 +0200
Subject: [PATCH] enum command_ret_t --> typedef

---
 avr/Tupfile        |  13 ++-
 avr/cli.c          |  10 +--
 avr/cmd_boot.c     |  28 +++----
 avr/cmd_echo.c     |   4 +-
 avr/cmd_help.c     |   2 +-
 avr/cmd_mem.c      | 194 ++++++++++++++++++++++-----------------------
 avr/cmd_mem.h      |  24 +++---
 avr/command.c      |  32 ++++----
 avr/command.h      |  75 +++++++++---------
 avr/command_tbl.c  |  22 ++---
 avr/debug.c        |  16 ++--
 avr/env.c          |  43 +++++-----
 fatfs/src/ffconf.h |   4 +-
 13 files changed, 239 insertions(+), 228 deletions(-)

diff --git a/avr/Tupfile b/avr/Tupfile
index 199b86c..8d36e0b 100644
--- a/avr/Tupfile
+++ b/avr/Tupfile
@@ -44,7 +44,18 @@ CFLAGS	+= -mmcu=$(MCU_TARGET)
 CFLAGS	+= -std=gnu99
 CFLAGS	+= -Wall -Wextra
 CFLAGS	+= -Wredundant-decls 
-#CFLAGS	+= -fno-common -ffunction-sections -fdata-sections
+CFLAGS	+= -mrelax 
+CFLAGS	+= -fno-common
+CFLAGS	+= -ffunction-sections
+CFLAGS	+= -fdata-sections
+CFLAGS	+= -fno-tree-loop-optimize
+CFLAGS	+= -fno-move-loop-invariants
+#CFLAGS	+= -flto
+CFLAGS	+= -fshort-enums
+
+#CFLAGS	+= -save-temps
+
+
 #CFLAGS	+= -I $(INCLUDES)
 
 CPPFLAGS += $(DEFS)
diff --git a/avr/cli.c b/avr/cli.c
index 4b77499..01ad81b 100644
--- a/avr/cli.c
+++ b/avr/cli.c
@@ -232,7 +232,7 @@ static int cli_run_command(const char *cmd, int flag)
 			continue;
 		}
 
-		if (cmd_process(flag, argc, argv, &repeatable))
+		if (cmd_process(flag, argc, argv, &repeatable) != CMD_RET_SUCCESS)
 			rc = -1;
 
 		/* Did the user stop this? */
@@ -331,7 +331,7 @@ void cli_loop(void)
 }
 
 
-int do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	int i;
 	(void) cmdtp;
@@ -345,12 +345,12 @@ int do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 		arg = getenv(argv[i]);
 		if (arg == NULL) {
 			printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
-			return 1;
+			return CMD_RET_FAILURE;
 		}
 
 		if (run_command(arg, flag) != 0)
-			return 1;
+			return CMD_RET_FAILURE;
 	}
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
diff --git a/avr/cmd_boot.c b/avr/cmd_boot.c
index 1699a5c..3e2dcdb 100644
--- a/avr/cmd_boot.c
+++ b/avr/cmd_boot.c
@@ -40,22 +40,22 @@ static void z80_load_mem(void)
 	}
 }
 
-int do_loadf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_loadf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	(void) cmdtp; (void) flag; (void) argc; (void) argv;
 
 	if (z80_bus_state() & ZST_RUNNING) {	
 		printf_P(PSTR("## Can't load while CPU is running!\n"));
-		return 1;	
+		return CMD_RET_FAILURE;	
 	}
 
 	z80_load_mem();
 	
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
 
-int do_busreq_pulse(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_busreq_pulse(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	uint16_t count=1;
 
@@ -63,7 +63,7 @@ int do_busreq_pulse(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
 	if (!(z80_bus_state() & ZST_RUNNING)) {	
 		printf_P(PSTR("## CPU is not running!\n"));
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 
 	if (argc > 1)
@@ -73,11 +73,11 @@ int do_busreq_pulse(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 	while (count--)
 		z80_bus_cmd(M_Cycle);
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
 
-int do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	uint32_t addr;
 
@@ -90,12 +90,12 @@ int do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 		printf_P(PSTR("## Startaddress 0x%05lx too high.\n"
 			"   (Out of logical address space (0x00000-0x0ffff))\n"),
 			addr);
-		return 1;
+		return CMD_RET_FAILURE;
 	} 
 
 	if (z80_bus_state() & ZST_RUNNING) {	
 		printf_P(PSTR("## CPU allready running!\n"));
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 
 	printf_P(PSTR("## Starting application at 0x%04lx ...\n"), addr);
@@ -121,25 +121,25 @@ int do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 		
 	z80_bus_cmd(Release);
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	(void) cmdtp; (void) flag; (void) argc; (void) argv;
 
 	printf_P(PSTR("## CPU now in reset state.\n"));
 
 	z80_bus_cmd(Reset);
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
-int do_restart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_restart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	(void) cmdtp; (void) flag; (void) argc; (void) argv;
 
 	z80_bus_cmd(Restart);
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
diff --git a/avr/cmd_echo.c b/avr/cmd_echo.c
index d142ab6..7ab8fef 100644
--- a/avr/cmd_echo.c
+++ b/avr/cmd_echo.c
@@ -9,7 +9,7 @@
 #include "command.h"
 
 
-int do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	uint_fast8_t putnl = 1;
 	
@@ -45,7 +45,7 @@ int do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 	if (putnl)
 		putchar('\n');
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
 #if 0
diff --git a/avr/cmd_help.c b/avr/cmd_help.c
index 317eb5d..b42fc87 100644
--- a/avr/cmd_help.c
+++ b/avr/cmd_help.c
@@ -2,7 +2,7 @@
 #include "common.h"
 #include "command.h"
 
-int do_help(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_help(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	const int len = cmd_tbl_item_count();
 	return _do_help(cmd_tbl, len, cmdtp, flag, argc, argv);
diff --git a/avr/cmd_mem.c b/avr/cmd_mem.c
index 253f02f..6341e0b 100644
--- a/avr/cmd_mem.c
+++ b/avr/cmd_mem.c
@@ -30,8 +30,6 @@
 #define CONFIG_SYS_MEMTEST_SCRATCH 0
 #endif
 
-static int mod_mem(cmd_tbl_t *, int, int, int, char * const []);
-
 /* Display values from last command.
  * Memory modify remembered values are different from display memory.
  */
@@ -116,7 +114,7 @@ int z180_dump_mem(uint32_t startaddr, uint32_t len, const char *title)
  * Syntax:
  *	md {addr} {len}
  */
-int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	uint32_t addr, length;
 	
@@ -154,19 +152,89 @@ int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
 	dp_last_addr = addr + length;
 	dp_last_length = length;
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
-int do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+/* Modify memory.
+ *
+ * Syntax:
+ *	mm {addr}
+ *	nm {addr}
+ */
+static command_ret_t
+mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
+{
+	uint32_t addr;
+	uint8_t data;
+	int nbytes;
+
+	(void) cmdtp;
+
+	if (argc != 2)
+		return CMD_RET_USAGE;
+
+	/* We use the last specified parameters, unless new ones are
+	 * entered.
+	 */
+	addr = mm_last_addr;
+
+	if ((flag & CMD_FLAG_REPEAT) == 0) {
+		/* New command specified.
+		 */
+
+		/* Address is specified since argc > 1
+		*/
+		addr = strtoul(argv[1], NULL, 16);
+		addr += base_address;
+	}
+
+	/* Print the address, followed by value.  Then accept input for
+	 * the next value.  A non-converted value exits.
+	 */
+	do {
+		z80_bus_cmd(Request);
+		data = z80_read(addr);
+		printf("%05lx: %02x", addr, data);
+		z80_bus_cmd(Release);
+
+		nbytes = cli_readline(PSTR(" ? "));
+		if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
+			/* <CR> pressed as only input, don't modify current
+			 * location and move to next. "-" pressed will go back.
+			 */
+			if (incrflag)
+				addr += nbytes ? -1 : 1;
+			nbytes = 1;
+		}
+		else {
+			char *endp;
+			data = strtoul(console_buffer, &endp, 16);
+			nbytes = endp - console_buffer;
+			if (nbytes) {
+				z80_bus_cmd(Request);
+				z80_write(addr, data);
+				z80_bus_cmd(Release);
+				if (incrflag)
+					addr++;
+			}
+		}
+	} while (nbytes);
+
+	mm_last_addr = addr;
+	return CMD_RET_SUCCESS;
+}
+
+
+command_ret_t do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	return mod_mem (cmdtp, 1, flag, argc, argv);
 }
-int do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	return mod_mem (cmdtp, 0, flag, argc, argv);
 }
 
-int do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	uint8_t writeval;
 	uint32_t addr, count;
@@ -200,11 +268,11 @@ int do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 	}
 	z80_bus_cmd(Release);
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
 #ifdef CONFIG_MX_CYCLIC
-int do_mem_mdc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_mdc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	int i;
 	uint32_t count;
@@ -225,14 +293,14 @@ int do_mem_mdc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 		/* check for ctrl-c to abort... */
 		if (ctrlc()) {
 			my_puts("Abort\n");
-			return 0;
+			return CMD_RET_SUCCESS;
 		}
 	}
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
-int do_mem_mwc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_mwc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	int i;
 	uint32_t count;
@@ -253,18 +321,18 @@ int do_mem_mwc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 		/* check for ctrl-c to abort... */
 		if (ctrlc()) {
 			my_puts("Abort\n");
-			return 0;
+			return CMD_RET_SUCCESS;
 		}
 	}
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 #endif /* CONFIG_MX_CYCLIC */
 
-int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	uint32_t addr1, addr2, count, ngood;
-	int rcode = 0;
+	command_ret_t rcode = CMD_RET_SUCCESS;
 	uint8_t byte1, byte2;
 
 	(void) cmdtp;
@@ -289,7 +357,7 @@ int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 			printf(	"byte at 0x%05lx (%#02x) != "
 				"byte at 0x%05lx (%#02x)\n",
 				addr1, byte1, addr2, byte2);
-			rcode = 1;
+			rcode = CMD_RET_FAILURE;
 			break;
 		}
 		addr1++;
@@ -298,7 +366,7 @@ int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 		/* check for ctrl-c to abort... */
 		if (ctrlc()) {
 			my_puts("Abort\n");
-			return 0;
+			return CMD_RET_SUCCESS;
 		}
 	}
 
@@ -306,7 +374,7 @@ int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 	return rcode;
 }
 
-int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	uint32_t src, dest, count;
 	int_fast8_t step;
@@ -325,7 +393,7 @@ int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
 	if (count == 0) {
 		my_puts ("Zero length ???\n");
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 	
 	if (dest > src) {
@@ -347,13 +415,13 @@ int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 		/* check for ctrl-c to abort... */
 		if (ctrlc()) {
 			my_puts("Abort\n");
-			return 0;
+			return CMD_RET_SUCCESS;
 		}
 	}
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
-int do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
+command_ret_t do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
 		       char * const argv[])
 {
 	(void) cmdtp;
@@ -365,10 +433,10 @@ int do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
 	}
 	/* Print the current base address. */
 	printf("Base Address: 0x%05lx\n", base_address);
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
-int do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc,
+command_ret_t do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc,
 		       char * const argv[])
 {
 	uint32_t addr, length;
@@ -405,11 +473,11 @@ int do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc,
 	}
 	z80_bus_cmd(Release);
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
 #ifdef CONFIG_LOOPW
-int do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	uint32_t addr, length;
 	uint8_t	data;
@@ -730,12 +798,13 @@ static uint32_t mem_test_quick(vu_long *buf, uint32_t start_addr, uint32_t end_a
  * configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until
  * interrupted by ctrl-c or by a failure of one of the sub-tests.
  */
-int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
+command_ret_t do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
 			char * const argv[])
 {
 	uint32_t start, end;
 	vu_long *buf, *dummy;
 	int iteration_limit;
+/* TODO: command_ret_t */
 	int ret;
 	uint32_t errs = 0;	/* number of errors, or -1 if interrupted */
 	uint32_t pattern;
@@ -807,72 +876,3 @@ int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
 }
 #endif	/* CONFIG_CMD_MEMTEST */
 
-/* Modify memory.
- *
- * Syntax:
- *	mm {addr}
- *	nm {addr}
- */
-static int
-mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
-{
-	uint32_t addr;
-	uint8_t data;
-	int nbytes;
-
-	(void) cmdtp;
-
-	if (argc != 2)
-		return CMD_RET_USAGE;
-
-	/* We use the last specified parameters, unless new ones are
-	 * entered.
-	 */
-	addr = mm_last_addr;
-
-	if ((flag & CMD_FLAG_REPEAT) == 0) {
-		/* New command specified.  
-		 */
-
-		/* Address is specified since argc > 1
-		*/
-		addr = strtoul(argv[1], NULL, 16);
-		addr += base_address;
-	}
-
-	/* Print the address, followed by value.  Then accept input for
-	 * the next value.  A non-converted value exits.
-	 */
-	do {
-		z80_bus_cmd(Request);
-		data = z80_read(addr);
-		printf("%05lx: %02x", addr, data);
-		z80_bus_cmd(Release);
-
-		nbytes = cli_readline(PSTR(" ? "));
-		if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
-			/* <CR> pressed as only input, don't modify current
-			 * location and move to next. "-" pressed will go back.
-			 */
-			if (incrflag)
-				addr += nbytes ? -1 : 1;
-			nbytes = 1;
-		}
-		else {
-			char *endp;
-			data = strtoul(console_buffer, &endp, 16);
-			nbytes = endp - console_buffer;
-			if (nbytes) {
-				z80_bus_cmd(Request);
-				z80_write(addr, data);
-				z80_bus_cmd(Release);
-				if (incrflag)
-					addr++;
-			}
-		}
-	} while (nbytes);
-
-	mm_last_addr = addr;
-	return 0;
-}
-
diff --git a/avr/cmd_mem.h b/avr/cmd_mem.h
index 9803fd2..cf379ce 100644
--- a/avr/cmd_mem.h
+++ b/avr/cmd_mem.h
@@ -7,23 +7,23 @@
 #include "cmd_mem.h"
 
 
-extern int do_mem_md(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_mm(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_nm(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_mw(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_cp(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_cmp(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_base(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_loop(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_md(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mm(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_nm(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mw(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_cp(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_cmp(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_base(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_loop(cmd_tbl_t *, int, int, char * const []);
 #ifdef CONFIG_LOOPW
-extern int do_mem_loopw(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_loopw(cmd_tbl_t *, int, int, char * const []);
 #endif
 #ifdef CONFIG_CMD_MEMTEST
-extern int do_mem_mtest(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mtest(cmd_tbl_t *, int, int, char * const []);
 #endif
 #ifdef CONFIG_MX_CYCLIC
-extern int do_mem_mdc(cmd_tbl_t *, int, int, char * const []);
-extern int do_mem_mwc(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mdc(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_mem_mwc(cmd_tbl_t *, int, int, char * const []);
 #endif /* CONFIG_MX_CYCLIC */
 
 #endif /* CMD_MEM_H */
diff --git a/avr/command.c b/avr/command.c
index df4bb98..9eb0ed2 100644
--- a/avr/command.c
+++ b/avr/command.c
@@ -67,11 +67,11 @@ int cmd_tbl_item_count(void)
  * for long help messages
  */
 
-int _do_help(cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp,
+command_ret_t _do_help(cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp,
 		int flag, int argc, char * const argv[])
 {
 	uint_fast8_t i;
-	int rcode = 0;
+	command_ret_t rcode = CMD_RET_SUCCESS;
 
 	(void) flag;
 
@@ -94,7 +94,7 @@ int _do_help(cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp,
 
 			/* allow user abort */
 			if (ctrlc ())
-				return 1;
+				return CMD_RET_FAILURE;
 			if (usage == NULL)
 				continue;
 #ifdef GCC_BUG_61443 
@@ -104,19 +104,19 @@ int _do_help(cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp,
 					cmd_array[i]->name, usage);
 #endif
 		}
-		return 0;
+		return CMD_RET_SUCCESS;
 	}
 	/*
 	 * command help (long version)
 	 */
 	for (i = 1; i < argc; ++i) {
 		if ((cmdtp = find_cmd_tbl (argv[i], cmd_start, cmd_items )) != NULL) {
-			rcode |= cmd_usage(cmdtp);
+			rcode = cmd_usage(cmdtp);
 		} else {
 			printf_P(PSTR("Unknown command '%s' - try 'help'"
 				" without arguments.\n\n"), argv[i]
 				);
-			rcode = 1;
+			rcode = CMD_RET_FAILURE;
 		}
 	}
 	return rcode;
@@ -162,7 +162,7 @@ cmd_tbl_t *find_cmd (const char *cmd)
 }
 
 
-int cmd_usage(const FLASH cmd_tbl_t *cmdtp)
+command_ret_t cmd_usage(const FLASH cmd_tbl_t *cmdtp)
 {
 //	printf("%s - %s\n\n", cmdtp->name, cmdtp->usage);
 	print_usage_line(cmdtp->name, cmdtp->usage);
@@ -181,13 +181,13 @@ int cmd_usage(const FLASH cmd_tbl_t *cmdtp)
 
 	if (!cmdtp->help) {
 		my_puts_P(PSTR(" - No additional help available.\n"));
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 
 	my_puts_P(cmdtp->help);
 	my_puts_P(PSTR("\n"));
 #endif	/* CONFIG_SYS_LONGHELP */
-	return 1;
+	return CMD_RET_FAILURE;
 }
 
 #ifdef CONFIG_AUTO_COMPLETE
@@ -459,31 +459,31 @@ int cmd_auto_complete(const FLASH char *const prompt, char *buf, int *np, int *c
  * @param argv		Arguments
  * @return 0 if command succeeded, else non-zero (CMD_RET_...)
  */
-static int cmd_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t cmd_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
-	int result;
+	command_ret_t result;
 
 	result = (cmdtp->cmd)(cmdtp, flag, argc, argv);
-	if (result)
+	if (result != CMD_RET_SUCCESS)
 		debug("Command failed, result=%d\n", result);
 	return result;
 }
 
-enum command_ret_t cmd_process(int flag, int argc, char * const argv[],
+command_ret_t cmd_process(int flag, int argc, char * const argv[],
 			       uint_fast8_t *repeatable)
 {
-	enum command_ret_t rc = CMD_RET_SUCCESS;
+	command_ret_t rc = CMD_RET_SUCCESS;
 	cmd_tbl_t *cmdtp;
 
 	/* Look up command in command table */
 	cmdtp = find_cmd(argv[0]);
 	if (cmdtp == NULL) {
 		printf_P(PSTR("Unknown command '%s' - try 'help'\n"), argv[0]);
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 	if (!cmdtp->cmd) {
 		debug("### Command '%s' found, but ->cmd == NULL \n", argv[0]);
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 
 	/* found - check max args */
diff --git a/avr/command.h b/avr/command.h
index 82b83ba..4e96903 100644
--- a/avr/command.h
+++ b/avr/command.h
@@ -17,6 +17,20 @@
 #define CONFIG_SYS_HELP_CMD_WIDTH	8
 #endif
 
+/*
+ * Error codes that commands return to cmd_process(). We use the standard 0
+ * and 1 for success and failure, but add one more case - failure with a
+ * request to call cmd_usage(). But the cmd_process() function handles
+ * CMD_RET_USAGE itself and after calling cmd_usage() it will return 1.
+ * This is just a convenience for commands to avoid them having to call
+ * cmd_usage() all over the place.
+ */
+typedef enum {
+	CMD_RET_SUCCESS,	/* 0 = Success */
+	CMD_RET_FAILURE,	/* 1 = Failure */
+	CMD_RET_USAGE = -1,	/* Failure, please report 'usage' error */
+} command_ret_t;
+
 /*
  * Monitor Command Table
  */
@@ -26,7 +40,7 @@ struct cmd_tbl_s {
 	int		maxargs;	/* maximum number of arguments	*/
 	int		repeatable;	/* autorepeat allowed?		*/
 					/* Implementation function	*/
-	int		(*cmd)(const FLASH struct cmd_tbl_s *, int, int, char * const []);
+	command_ret_t	(*cmd)(const FLASH struct cmd_tbl_s *, int, int, char * const []);
 	const FLASH char *usage;		/* Usage message	(short)	*/
 #ifdef	CONFIG_SYS_LONGHELP
 	const FLASH char *help;		/* Help  message	(long)	*/
@@ -39,16 +53,32 @@ struct cmd_tbl_s {
 
 typedef const FLASH struct cmd_tbl_s cmd_tbl_t;
 
-extern int do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern command_ret_t do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+
+/**
+ * Process a command with arguments. We look up the command and execute it
+ * if valid. Otherwise we print a usage message.
+ *
+ * @param flag		Some flags normally 0 (see CMD_FLAG_.. above)
+ * @param argc		Number of arguments (arg 0 must be the command text)
+ * @param argv		Arguments
+ * @param repeatable	This function sets this to 0 if the command is not
+ *			repeatable. If the command is repeatable, the value
+ *			is left unchanged.
+ * @return 0 if the command succeeded, 1 if it failed
+ */
+command_ret_t
+cmd_process(int flag, int argc, char * const argv[], uint_fast8_t *repeatable);
+
 
 /* command.c */
-int _do_help (cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp, int
+command_ret_t _do_help (cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp, int
 	      flag, int argc, char * const argv[]);
 cmd_tbl_t *find_cmd(const char *cmd);
 cmd_tbl_t *find_cmd_tbl (const char *cmd, cmd_tbl_t *table, int table_len);
 
 int cmd_tbl_item_count(void);
-int cmd_usage(cmd_tbl_t *cmdtp);
+command_ret_t cmd_usage(cmd_tbl_t *cmdtp);
 
 #ifdef CONFIG_AUTO_COMPLETE
 extern int var_complete(int argc, char * const argv[], char last_char, int maxv, char *cmdv[]);
@@ -74,10 +104,10 @@ int cmd_process_error(cmd_tbl_t *cmdtp, int err);
 
 
 #ifdef CONFIG_CMD_BOOTD
-extern int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern command_ret_t do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
 #endif
 #ifdef CONFIG_CMD_BOOTM
-extern int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern command_ret_t do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
 extern int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd);
 #else
 static inline int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
@@ -91,36 +121,7 @@ static inline int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
 extern int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
 			   char *const argv[]);
 
-extern int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-
-/*
- * Error codes that commands return to cmd_process(). We use the standard 0
- * and 1 for success and failure, but add one more case - failure with a
- * request to call cmd_usage(). But the cmd_process() function handles
- * CMD_RET_USAGE itself and after calling cmd_usage() it will return 1.
- * This is just a convenience for commands to avoid them having to call
- * cmd_usage() all over the place.
- */
-enum command_ret_t {
-	CMD_RET_SUCCESS,	/* 0 = Success */
-	CMD_RET_FAILURE,	/* 1 = Failure */
-	CMD_RET_USAGE = -1,	/* Failure, please report 'usage' error */
-};
-
-/**
- * Process a command with arguments. We look up the command and execute it
- * if valid. Otherwise we print a usage message.
- *
- * @param flag		Some flags normally 0 (see CMD_FLAG_.. above)
- * @param argc		Number of arguments (arg 0 must be the command text)
- * @param argv		Arguments
- * @param repeatable	This function sets this to 0 if the command is not
- *			repeatable. If the command is repeatable, the value
- *			is left unchanged.
- * @return 0 if the command succeeded, 1 if it failed
- */
-int cmd_process(int flag, int argc, char * const argv[], uint_fast8_t *repeatable);
-
+extern command_ret_t do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
 
 /*
  * Command Flags:
@@ -149,7 +150,7 @@ int cmd_process(int flag, int argc, char * const argv[], uint_fast8_t *repeatabl
 	CMD_TBL_ITEM_COMPLETE(_name, _maxargs, _rep, _cmd,		\
 					_usage, _help, NULL)
 
-typedef int (*do_cmd_t)(cmd_tbl_t *, int, int, char * const []);
+typedef command_ret_t (*do_cmd_t)(cmd_tbl_t *, int, int, char * const []);
 
 extern  cmd_tbl_t cmd_tbl[];
 
diff --git a/avr/command_tbl.c b/avr/command_tbl.c
index 69f6273..2fb41b9 100644
--- a/avr/command_tbl.c
+++ b/avr/command_tbl.c
@@ -5,17 +5,17 @@
 #include "cmd_mem.h"
 
 
-extern int do_help(cmd_tbl_t *, int, int, char * const []);
-extern int do_echo(cmd_tbl_t *, int, int, char * const []);
-extern int do_env_print(cmd_tbl_t *, int, int, char * const []);
-extern int do_env_set(cmd_tbl_t *, int, int, char * const []);
-extern int do_env_save(cmd_tbl_t *, int, int, char * const []);
-extern int do_loadf(cmd_tbl_t *, int, int, char * const []);
-extern int do_go(cmd_tbl_t *, int, int, char * const []);
-extern int do_restart(cmd_tbl_t *, int, int, char * const []);
-extern int do_dump_mem(cmd_tbl_t *, int, int, char * const []);
-extern int do_eep_cp(cmd_tbl_t *, int, int, char * const []);
-extern int do_busreq_pulse(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_help(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_echo(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_env_print(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_env_set(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_env_save(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_loadf(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_go(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_restart(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_dump_mem(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_eep_cp(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_busreq_pulse(cmd_tbl_t *, int, int, char * const []);
 
 
 cmd_tbl_t cmd_tbl[] = {
diff --git a/avr/debug.c b/avr/debug.c
index e62869b..4591397 100644
--- a/avr/debug.c
+++ b/avr/debug.c
@@ -140,7 +140,7 @@ void dump_eep(const uint8_t *addr, unsigned int len,
  * EEPROM Display
  *	md addr {len}
  */
-int do_dump_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_dump_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 //	static const uint8_t *addr;
 //	static uint16_t length = 128;
@@ -171,10 +171,10 @@ int do_dump_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 	/* Print the lines. */
 	dump_mem(addr, length, readhow, NULL);
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
-int do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	uint16_t src, dest, count;
 	int_fast8_t step;
@@ -191,19 +191,19 @@ int do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
 	if (src > E2END) {
 		debug("src > EEPROM size: 0x%04x\n", src);
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 	if (dest > E2END) {
 		debug("dest > EEPROM size: 0x%04x\n", dest);
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 	if (count > E2END+1) {
 		debug("count > EEPROM size: 0x%04x\n", count);
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 	if (count == 0) {
 		debug("Zero length ???\n");
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 
 	if (dest > src) {
@@ -221,7 +221,7 @@ int do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 		dest += step;
 
 	}
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 #endif /* DEBUG */
 
diff --git a/avr/env.c b/avr/env.c
index 7cf33ac..8487c6f 100644
--- a/avr/env.c
+++ b/avr/env.c
@@ -596,34 +596,33 @@ int env_print_ramsize(void)
 }
 
 
-int do_env_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_env_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
-	int i;
-	int rcode = 0;
+	command_ret_t rc = CMD_RET_SUCCESS;
 
 	(void) cmdtp; (void) flag;
 
 	if (argc == 1) {
 		/* print all env vars */
-		rcode = env_print(NULL);
-		if (rcode < 0)
-			return 1;
+		int size = env_print(NULL);
+		if (size < 0)
+			return CMD_RET_FAILURE;
 		printf_P(PSTR("\nEnvironment size: %d/%d bytes\n"),
-			rcode, ENV_SIZE);
+			size, ENV_SIZE);
 		env_print_ramsize();
-		return 0;
+		return CMD_RET_SUCCESS;
 	}
 
 	/* print selected env vars */
-	for (i = 1; i < argc; ++i) {
+	for (int i = 1; i < argc; ++i) {
 		int rc = env_print(argv[i]);
 		if (rc < 0) {
 			printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
-			++rcode;
+			rc = CMD_RET_FAILURE;
 		}
 	}
 
-	return rcode;
+	return rc;
 }
 
 
@@ -642,7 +641,7 @@ int do_env_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  * @return 0 if ok, 1 on error
  */
 static
-int _do_env_set(int flag, int argc, char * const argv[])
+command_ret_t _do_env_set(int flag, int argc, char * const argv[])
 {
 	int i, len;
 	char *name, *value, *s;
@@ -657,12 +656,12 @@ int _do_env_set(int flag, int argc, char * const argv[])
 	if (strchr(name, '=')) {
 		printf_P(PSTR("## Error: illegal character '='"
 		       "in variable name \"%s\"\n"), name);
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 	if (strlen(name) > CONFIG_SYS_ENV_NAMELEN) {
 		printf_P(PSTR("## Error: Variable name \"%s\" too long. "
 		       "(max %d characters)\n"), name, CONFIG_SYS_ENV_NAMELEN);
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 /*
 	env_id++;
@@ -670,7 +669,7 @@ int _do_env_set(int flag, int argc, char * const argv[])
 	/* Delete only ? */
 	if (argc < 3 || argv[2] == NULL) {
 		int rc = envlist_delete(name);
-		return rc != 0;
+		return rc ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
 	}
 
 	/*
@@ -682,7 +681,7 @@ int _do_env_set(int flag, int argc, char * const argv[])
 	value = xmalloc(len);
 	if (value == NULL) {
 		printf_P(PSTR("## Can't malloc %d bytes\n"), len);
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 	for (i = 2, s = value; i < argc; ++i) {
 		char *v = argv[i];
@@ -701,10 +700,10 @@ int _do_env_set(int flag, int argc, char * const argv[])
 	if (!ep) {
 		printf_P(PSTR("## Error inserting \"%s\" variable.\n"),
 			name);
-		return 1;
+		return CMD_RET_FAILURE;
 	}
 
-	return 0;
+	return CMD_RET_SUCCESS;
 }
 
 /**
@@ -723,7 +722,7 @@ int setenv(const char *varname, const char *varvalue)
 	if (varvalue == NULL || varvalue[0] == '\0')
 		--argc;
 		
-	return _do_env_set(0, argc, (char * const *)argv);
+	return (int) _do_env_set(0, argc, (char * const *)argv);
 }
 
 #if 0
@@ -781,7 +780,7 @@ unsigned long getenv_hex(const char *varname, unsigned long default_val)
 	return value;
 }
 
-int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	(void) cmdtp;
 
@@ -792,12 +791,12 @@ int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 }
 
 
-int do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	(void) cmdtp; (void) flag; (void) argc;	(void) argv;
 
 	printf_P(PSTR("Saving Environment ...\n"));
-	return saveenv() ? 1 : 0;
+	return saveenv() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
 }
 
 #if defined(CONFIG_AUTO_COMPLETE) 
diff --git a/fatfs/src/ffconf.h b/fatfs/src/ffconf.h
index d883c14..2010c87 100644
--- a/fatfs/src/ffconf.h
+++ b/fatfs/src/ffconf.h
@@ -119,7 +119,7 @@
 /  FatFs supports only BMP. */
 
 
-#define _FS_RPATH		0	/* 0 to 2 */
+#define _FS_RPATH		2	/* 0 to 2 */
 /* The _FS_RPATH option configures relative path feature.
 /
 /   0: Disable relative path feature and remove related functions.
@@ -201,7 +201,7 @@
 */
 
 
-#define _WORD_ACCESS	0	/* 0 or 1 */
+#define _WORD_ACCESS	1	/* 0 or 1 */
 /* The _WORD_ACCESS option is an only platform dependent option. It defines
 /  which access method is used to the word data on the FAT volume.
 /
-- 
2.39.2