X-Git-Url: http://cloudbase.mooo.com/gitweb/z180-stamp.git/blobdiff_plain/73cf0c86a2fd0d85ad30c9b996264e44c49d7bd0..refs/heads/fatcommands:/avr/cmd_fat.c

diff --git a/avr/cmd_fat.c b/avr/cmd_fat.c
index 633834c..33d6051 100644
--- a/avr/cmd_fat.c
+++ b/avr/cmd_fat.c
@@ -9,6 +9,7 @@
  */
 
 #include "cmd_fat.h"
+#include <util/delay.h>
 
 #include "ff.h"
 #include "z80-if.h"
@@ -21,12 +22,34 @@
 #include "env.h"
 #include "getopt-min.h"
 
+
+#define DEBUG_CP		1	/* set to 1 to debug */
+#define DEBUG_LS		1	/* set to 1 to debug */
+#define DEBUG_RM		1	/* set to 1 to debug */
+#define DEBUG_FA		1	/* set to 1 to debug */
+
+#define debug_cp(fmt, args...)		                                               \
+	debug_cond(DEBUG_CP, fmt, ##args)
+#define debug_ls(fmt, args...)		                                               \
+	debug_cond(DEBUG_LS, fmt, ##args)
+#define debug_rm(fmt, args...)		                                               \
+	debug_cond(DEBUG_RM, fmt, ##args)
+#define debug_fa(fmt, args...)		                                               \
+	debug_cond(DEBUG_FA, fmt, ##args)
+
+
+
 /* TODO: use memory size test function (detect_ramsize() in cmd_loadihex.c) */
 /* TODO: detect_ramsize() should be moved to z80-if.c */
 #define MAX_MEMORY	CONFIG_SYS_RAMSIZE_MAX
 #define BUFFER_SIZE	512
-#define MAXBSIZE	512 /* TODO */
+#define MAX_PATHLEN CONFIG_SYS_MAX_PATHLEN
+
 
+typedef struct {
+	char *p_end;			/* pointer to NULL at end of path */
+	char p_path[MAX_PATHLEN + 1];	/* pointer to the start of a path */
+} PATH_T;
 
 /*
  * Multible (fat) partitions per physical drive are not supported,
@@ -35,7 +58,22 @@
 FATFS FatFs0;
 FATFS FatFs1;
 
+uint8_t *blockbuf;
+int blockbuf_size;
+PATH_T from;
+PATH_T to;
 command_ret_t command_ret;
+char *cmdname;
+
+static uint8_t flags;
+#define F_FLAG	(1<<3)	// overwrite existing file ignoring write protection
+#define I_FLAG	(1<<1)	// prompt before overwrite (overrides a previous -n option)
+#define N_FLAG	(1<<2)	// do not overwrite an existing file (overrides a previous -i option)
+#define P_FLAG	(1<<4)	// preserve attributes and timestamps
+#define R_FLAG	(1<<0)	// copy directories recursively
+#define V_FLAG	(1<<5)	// explain what is being done
+
+
 
 void setup_fatfs(void)
 {
@@ -134,14 +172,208 @@ void err(const char *fmt, ...)
 {
 	va_list ap;
 	va_start(ap, fmt);
-//	(void)fprintf(stderr, "%s: ", progname);
-	(void)vfprintf_P(stdout, fmt, ap);
+	printf_P(PSTR("fat %s: "), cmdname);
+	vfprintf_P(stdout, fmt, ap);
 	va_end(ap);
-	(void)printf_P(PSTR("\n"));
+	printf_P(PSTR("\n"));
+	_delay_ms(20);
 	command_ret = CMD_RET_FAILURE;
 }
 
+/******************************************************************************/
+
+/*
+ * These functions manipulate paths in PATH_T structures.
+ *
+ * They eliminate multiple slashes in paths when they notice them,
+ * and keep the path non-slash terminated.
+ *
+ * Both path_set() and path_append() return 0 if the requested name
+ * would be too long.
+ */
+
+
+static void path_init(void)
+{
+	from.p_path[0] = '\0'; from.p_end = from.p_path;
+	to.p_path[0] = '\0';   to.p_end = to.p_path;
+}
+
+static char *path_skip_heading(char *p)
+{
+	if ((p[0] & 0x38) == '0' &&  p[1] == ':') {
+		p += 2;
+	} else {
+		char *q = p;
+		if (*q++ == '.') {
+			if (*q == '.')
+				++q;
+			if (*q == '\0' || *q == '/')
+				p = q;
+		}
+		return p;
+	}
+	if (*p == '/')
+		++p;
+
+	return p;
+}
+
+static void strip_trailing_slash(PATH_T *p)
+{
+	char *beg = path_skip_heading(p->p_path);
+	char *end = p->p_end;
+
+	while (end > beg && end[-1] == '/')
+		*--end = '\0';
+
+	p->p_end =end;
+}
+
+/*
+ * Move specified string into path.  Convert "" to "." to handle BSD
+ * semantics for a null path.  Strip trailing slashes.
+ */
+int
+path_set(PATH_T *p, char *string)
+{
+	if (strlen(string) > MAX_PATHLEN) {
+		err(PSTR("set: '%s': name too long"), string);
+		return 0;
+	}
+
+	(void)strcpy(p->p_path, string);
+	p->p_end = p->p_path + strlen(p->p_path);
+
+	if (p->p_path == p->p_end) {
+		*p->p_end++ = '.';
+		*p->p_end = '\0';
+	}
+
+	strip_trailing_slash(p);
+	return 1;
+}
+
+/*
+ * Append specified string to path, inserting '/' if necessary.  Return a
+ * pointer to the old end of path for restoration.
+ */
+char *
+path_append(PATH_T *p, char *name)
+{
+	char *old = p->p_end;
+	int len = strlen(name);
+
+	/* The "+ 1" accounts for the '/' between old path and name. */
+	if ((len + p->p_end - p->p_path + 1) > MAX_PATHLEN) {
+		err(PSTR("append: '%s/%s': name too long"), p->p_path, name);
+		return NULL;
+	}
+
+	/*
+	 * This code should always be executed, since paths shouldn't
+	 * end in '/'.
+	 */
+	if (p->p_end[-1] != '/') {
+		*p->p_end++ = '/';
+		*p->p_end = '\0';
+	}
+
+	strncat(p->p_end, name, len);
+	p->p_end += len;
+	*p->p_end = '\0';
+
+	strip_trailing_slash(p);
+	return old;
+}
+
+/*
+ * Restore path to previous value.  (As returned by path_append.)
+ */
+void
+path_restore(PATH_T *p, char *old)
+{
+	p->p_end = old;
+	*p->p_end = '\0';
+}
+
+/*
+ * Return basename of path.
+ */
+char *path_basename(PATH_T *p)
+{
+	char *basename = strrchr(p->p_path, '/');
+
+	if (basename) {
+		++basename;
+	} else {
+		basename = p->p_path;
+		if ((basename[0] & 0x38) == '0' &&  basename[1] == ':')
+			basename += 2;
+	}
+
+	return basename;
+}
 
+#if 0
+char *path_basename_pattern(PATH_T *p)
+{
+	char *pattern = path_basename(p);
+	if (strpbrk_P(pattern, PSTR("*?"))) {
+		memmove(pattern+1, pattern, strlen(pattern)+1);
+		*pattern++ = '\0';
+	} else {
+		//p->p_pattern = p->p_end + 1;
+		pattern = p->p_end + 1;
+		pattern[0] = '*';
+		pattern[1] = '\0';
+	}
+	return pattern;
+}
+#endif
+
+/*
+ * Split path
+ * Return basename/pattern of path.
+ */
+
+char *path_split_pattern(PATH_T *p)
+{
+	char *pp = path_skip_heading(p->p_path);
+	char *pattern = strrchr(pp, '/');
+
+	if (pattern == NULL) {
+		pattern = pp;
+		p->p_end = pattern;
+	} else {
+		p->p_end = pattern;
+		pattern++;
+	}
+	memmove(pattern+2, pattern, strlen(pattern)+1);
+	pattern += 2;
+	*p->p_end = '\0' ;
+
+	return pattern;
+}
+
+void path_fix(PATH_T *p)
+{
+	char *pp = path_skip_heading(p->p_path);
+
+	if (pp != p->p_end) {
+		*p->p_end++ = '/';
+		*p->p_end = '\0' ;
+	}
+}
+
+void path_unfix(PATH_T *p)
+{
+	char *pp = path_skip_heading(p->p_path);
+
+	if (pp != p->p_end) {
+		*--p->p_end = '\0' ;
+	}
+}
 
 static void swirl(void)
 {
@@ -163,26 +395,18 @@ static void swirl(void)
 command_ret_t do_pwd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
 {
 	FRESULT res;
-	char *buf;
 
-	buf = (char *) malloc(BUFFER_SIZE);
-	if (buf == NULL) {
-		printf_P(PSTR("pwd: Out of Memory!\n"));
-		free(buf);
-		return CMD_RET_FAILURE;
-	}
+	cmdname = argv[0];
+	command_ret = CMD_RET_SUCCESS;
 
-	res = f_getcwd(buf, BUFFER_SIZE);  /* Get current directory path */
+	res = f_getcwd(from.p_path, MAX_PATHLEN);  /* Get current directory path */
 
-	if (!res) {
-		puts(buf);
-	}
-	free(buf);
-	if (res) {
-		put_rc(res);
-		return CMD_RET_FAILURE;
-	}
-	return CMD_RET_SUCCESS;
+	if (res == FR_OK)
+		puts(from.p_path);
+	else
+		err(PSTR("Error: %S"), rctostr(res));
+
+	return command_ret;
 }
 
 
@@ -193,60 +417,240 @@ command_ret_t do_pwd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc
 command_ret_t do_cd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
 {
 	char *arg;
-	FRESULT res = 0;
+	FRESULT res = FR_OK;
+
+	cmdname = argv[0];
+	command_ret = CMD_RET_SUCCESS;
 
 	if (argc < 2) {
 		arg = getenv_str(PSTR(ENV_HOME));
 		if (arg == NULL) {
-			printf_P(PSTR("%s: \"%S\" is not set\n"), argv[0], PSTR(ENV_HOME));
-			return CMD_RET_FAILURE;
+			err(PSTR("'%S' is not set"), PSTR(ENV_HOME));
+			return command_ret;
 		}
 	} else
 		arg = argv[1];
 
-	if (arg[1] == ':') {
-		char drv[3];
-		drv[2] = '\0';
-		drv[1] = ':';
-		drv[0] = arg[0];
-		res = f_chdrive(drv);
-	}
-	if (!res) {
+	if (arg[1] == ':')
+		res = f_chdrive(arg);
+	if (res == FR_OK)
 		res = f_chdir(arg);
-	}
+	if (res != FR_OK)
+		err(PSTR("'%s': %S"), arg, rctostr(res));
 
-	if (res) {
-		put_rc(res);
-		return CMD_RET_FAILURE;
+	return command_ret;
+}
+
+
+static int decode_arg(const char *arg)
+{
+	BYTE attr = 0;
+	char c;
+
+	while ((c = *++arg) != '\0') {
+		switch (c) {
+			case 'a':
+				attr |= AM_ARC;		/* Archive   */
+				break;
+			case 'h':
+				attr |= AM_HID;		/* Hidden    */
+				break;
+			case 'r':
+				attr |= AM_RDO;		/* Read only */
+				break;
+			case 's':
+				attr |= AM_SYS;		/* System    */
+				break;
+			default:
+				err(PSTR("unknown attribute: '%c'"), c);
+				return -1;
+		}
 	}
-	return CMD_RET_SUCCESS;
+	return attr;
 }
 
-#define MAX_PATHLEN CONFIG_SYS_MAX_PATHLEN
+static void print_attrib(char *path, FILINFO *f)
+{
+	printf_P(PSTR("%c%c%c%c%c %s%s\n"),
+				(f->fattrib & AM_DIR) ? 'D' : '-',
+				(f->fattrib & AM_RDO) ? 'R' : '-',
+				(f->fattrib & AM_HID) ? 'H' : '-',
+				(f->fattrib & AM_SYS) ? 'S' : '-',
+				(f->fattrib & AM_ARC) ? 'A' : '-',
+				path, f->fname);
+}
 
-/*
- * Remove trailing slashes,
- * but keep a leading slash (absolute path)
- */
-void strip_trailing_slash_relpath(char *p)
+command_ret_t do_attrib(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, UNUSED char * const argv[])
 {
-	int n = strlen(p);
+	DIR Dir;					/* Directory object */
+	FILINFO Finfo;
+	FRESULT res;
+	BYTE set_mask = 0;
+	BYTE clear_mask = 0;
 
-	if (n >= 2 && (p[0] & 0x38) == '0' &&  p[1] == ':') {
-		p += 2;
-		n -= 2;
+	cmdname = argv[0];
+	command_ret = CMD_RET_SUCCESS;
+
+
+	for (;;) {
+		int attr;
+		char *arg = *++argv;
+
+		if (!arg)
+			return CMD_RET_USAGE;
+		if (arg[0] != '-' && arg[0] != '+')
+			break;
+		attr = decode_arg(arg);
+		if (attr < 0)
+			return CMD_RET_FAILURE;
+		if (arg[0] == '+')
+			set_mask |= attr;
+		else
+			clear_mask |= attr;
 	}
-	if (n >= 1 &&  p[0] == '/') {
-		p++;
-		n--;
+
+	do {
+		if (!path_set(&from, *argv)) {
+			/* TODO: error out*/
+		}
+		char *pattern = path_split_pattern(&from);
+		if (*pattern == '\0')
+			pattern = "*";
+		debug_fa("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", pattern ? pattern : "<NULL>");
+		res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+		debug_fa("==== findfirst %d\n", res);
+		if (res != FR_OK || !Finfo.fname[0]) {
+			path_fix(&from);
+			err(PSTR("'%s%s': No such file or directory"), from.p_path, pattern);
+		} else {
+			do {
+				if (set_mask | clear_mask) {
+					if ((res = f_chmod(Finfo.fname, set_mask, set_mask | clear_mask)) != FR_OK) {
+						path_fix(&from);
+						err(PSTR("'%s%s': %S"), from.p_path, Finfo.fname, rctostr(res));
+						path_unfix(&from);
+					}
+				} else {
+					path_fix(&from);
+					print_attrib(from.p_path, &Finfo);
+					path_unfix(&from);
+				}
+
+				res = f_findnext(&Dir, &Finfo);
+				//debug_fa("==== findnext %d\n", res);
+			} while (res == FR_OK && Finfo.fname[0]);
+		}
+		f_closedir(&Dir);
+	} while (*++argv);
+
+	return command_ret;
+}
+
+command_ret_t do_rm(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+	DIR Dir;					/* Directory object */
+	FILINFO Finfo;
+	FRESULT res;
+
+	cmdname = argv[0];
+	command_ret = CMD_RET_SUCCESS;
+
+	/* reset getopt() */
+	optind = 0;
+	flags = 0;
+
+	int opt;
+	while ((opt = getopt(argc, argv, PSTR("nv"))) != -1) {
+		switch (opt) {
+			case 'n':
+				flags |=  N_FLAG;
+				break;
+			case 'v':
+				flags |=  V_FLAG;
+				break;
+			default:
+				return CMD_RET_USAGE;
+				break;
+		}
 	}
-	while (n-- != 0  && p[n] == '/')
-			p[n] = '\0';
+	argc -= optind;
+	argv += optind;
+
+	if (argc < 1) {
+		err(PSTR("missing operand"));
+	} else {
+		for (int i = 0; i < argc; i++) {
+			if (!path_set(&from, argv[i])) {
+				/* TODO: error out*/
+			}
+			char *pattern = path_split_pattern(&from);
+
+			debug_rm("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", pattern ? pattern : "<NULL>");
+
+			res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+			debug_rm("==== findfirst %d\n", res);
+
+			if (res != FR_OK || !Finfo.fname[0]) {
+				path_fix(&from);
+				err(PSTR("cannot remove '%s%s': No such file or directory"), from.p_path, pattern);
+			} else {
+				do {
+					if (Finfo.fattrib & AM_DIR) {
+						path_fix(&from);
+						err(PSTR("cannot remove '%s%s': Is a directory"), from.p_path, Finfo.fname);
+					} else {
+						if (!(flags & N_FLAG)) {
+							if ((res = f_unlink(Finfo.fname)) == FR_OK) {
+								if (flags & V_FLAG)
+									path_fix(&from);
+									printf_P(PSTR("removed '%s%s'\n"), from.p_path, Finfo.fname);
+									path_unfix(&from);
+							} else {
+								path_fix(&from);
+								err(PSTR("cannot remove '%s%s': %S"), from.p_path, Finfo.fname, rctostr(res));
+							}
+						} else {
+							path_fix(&from);
+							printf_P(PSTR("not removed '%s%s'\n"), from.p_path, Finfo.fname);
+							path_unfix(&from);
+						}
+					}
+					res = f_findnext(&Dir, &Finfo);
+					//debug_rm("==== findnext %d\n", res);
+				} while (res == FR_OK && Finfo.fname[0]);
+			}
+			f_closedir(&Dir);
+		}
+
+		/* TODO */
+		if (res) {
+			put_rc(res);
+			return CMD_RET_FAILURE;
+		}
+	}
+	return command_ret;
+}
+
+command_ret_t do_rmdir(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+	cmdname = argv[0];
+	command_ret = CMD_RET_SUCCESS;
+
+	return command_ret;
+}
+
+command_ret_t do_mkdir(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+	cmdname = argv[0];
+	command_ret = CMD_RET_SUCCESS;
+
+	return command_ret;
 }
 
-int print_dirent(FILINFO *f)
+
+static void print_dirent(FILINFO *f)
 {
-	return printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu  %s\n"),
+	printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu  %s\n"),
 				(f->fattrib & AM_DIR) ? 'D' : '-',
 				(f->fattrib & AM_RDO) ? 'R' : '-',
 				(f->fattrib & AM_HID) ? 'H' : '-',
@@ -270,60 +674,56 @@ command_ret_t do_ls(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc,
 	unsigned int s1, s2;
 	FRESULT res;
 
-	char *path = "";
-	if (argc > 1)
-		path = argv[1];
-	strip_trailing_slash_relpath(path);
-
-	char *p = strrchr(path, '/');
-	if (p)
-		p++;
-	else {
-		p = path;
-		char *q = p;
-		if ((*q++ & 0x38) == '0' &&  *q++ == ':')
-			p = q;
-	}
+	cmdname = argv[0];
+	command_ret = CMD_RET_SUCCESS;
 
-	char *pattern;
-	if (strpbrk_P(p, PSTR("*?")) ||
-			(f_stat(path, &Finfo) == FR_OK && !(Finfo.fattrib & AM_DIR))) {
-		pattern = strdup(p);
-		*p = '\0';
-	} else
-		pattern = strdup("*");
-	strip_trailing_slash_relpath(path);
+	path_init();
+	if (argc > 1)
+		if (!path_set(&from, argv[1])) {
+			/* TODO: error out*/
+		}
 
-//printf_P(PSTR("*: |%s| |%s|\n"), path ? path : "<NULL>", pattern ? pattern : "<NULL>");
+#if 0
+	char *pattern = path_basename_pattern(&from);
+#else
+	char *pattern = path_split_pattern(&from);
+	if (*pattern == '\0')
+		pattern = "*";
+#endif
+	debug_ls("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", pattern ? pattern : "<NULL>");
 
 	p1 = s1 = s2 = 0;
-	res = f_findfirst(&Dir, &Finfo, path, pattern);  /* Start to search for files */
-	while (res == FR_OK && Finfo.fname[0]) {
-		if (Finfo.fattrib & AM_DIR) {
-			s2++;
-		} else {
-			s1++; p1 += Finfo.fsize;
-		}
-		print_dirent(&Finfo);
-		if (check_abort())
-			break;
-		res = f_findnext(&Dir, &Finfo);
+	res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);  /* Start to search for files */
+	if (res != FR_OK || !Finfo.fname[0]) {
+		path_fix(&from);
+		err(PSTR("'%s%s': No such file or directory"), from.p_path, pattern);
+	} else {
+		do {
+			if (Finfo.fattrib & AM_DIR) {
+				s2++;
+			} else {
+				s1++; p1 += Finfo.fsize;
+			}
+			print_dirent(&Finfo);
+			if (check_abort())
+				break;
+			res = f_findnext(&Dir, &Finfo);
+		} while (res == FR_OK && Finfo.fname[0]);
 	}
 	f_closedir(&Dir);
-	free(pattern);
 
-	if (res == FR_OK) {
+	if (res == FR_OK && command_ret == CMD_RET_SUCCESS) {
 		printf_P(PSTR("%4u File(s),%10lu bytes total\n%4u Dir(s)"), s1, p1, s2);
-		if (f_getfree(path, (DWORD*)&p1, &fs) == FR_OK)
+		if (f_getfree(from.p_path, (DWORD*)&p1, &fs) == FR_OK)
 			printf_P(PSTR(", %10luK bytes free\n"), p1 * fs->csize / 2);
 	}
 
-	if (res) {
+	if (res && command_ret == CMD_RET_SUCCESS) {
 		put_rc(res);
 		return CMD_RET_FAILURE;
 	}
 
-	return CMD_RET_SUCCESS;
+	return command_ret;
 }
 
 /*
@@ -335,20 +735,20 @@ command_ret_t do_tst(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc
 	DIR Dir;					/* Directory object */
 	FILINFO Finfo;
 	FRESULT res = FR_OK;
-	char *path;
+	char *path = "";
+	char *pattern = "*";
 
 	printf_P(PSTR("sizeof DIR: %u, sizeof FIL: %u\n"), sizeof (DIR), sizeof (FILINFO));
 
 	char * buf = (char *) malloc(BUFFER_SIZE);
 	if (buf == NULL) {
-		printf_P(PSTR("pwd: Out of Memory!\n"));
-		free(buf);
+		printf_P(PSTR("tst: Out of Memory!\n"));
 		return CMD_RET_FAILURE;
 	}
 	res = f_getcwd(buf, BUFFER_SIZE);  /* Get current directory path */
 
 	if (!res) {
-		printf_P(PSTR("cwd: |%s|\n"), buf);
+		printf_P(PSTR("cwd: '%s'\n"), buf);
 	}
 	free(buf);
 	if (res) {
@@ -358,10 +758,10 @@ command_ret_t do_tst(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc
 
 	if (argc > 1)
 		path = argv[1];
-	else
-		path = "";
+	if (argc > 2)
+		pattern = argv[2];
 
-	printf_P(PSTR("arg: |%s|\n"), path);
+	printf_P(PSTR("arg: '%s' '%s'\n"), path, pattern);
 	printf_P(PSTR("==== f_stat:      "));
 	res = f_stat(path, &Finfo);
 	put_rc(res);
@@ -370,7 +770,7 @@ command_ret_t do_tst(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc
 	}
 
 	printf_P(PSTR("==== f_findfirst: "));
-	res = f_findfirst(&Dir, &Finfo, path, "*");  /* Start to search for files */
+	res = f_findfirst(&Dir, &Finfo, path, pattern);  /* Start to search for files */
 	put_rc(res);
 	if (res == FR_OK) {
 		print_dirent(&Finfo);
@@ -385,327 +785,151 @@ command_ret_t do_tst(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc
 	return CMD_RET_SUCCESS;
 }
 
-#if 0
-static
-FRESULT mkpath(TCHAR *path)
-{
-	/* TODO: */
-	(void) path;
-	FILINFO fd
-	TCHAR *p, *q;
-	FRESULT ret;
-
-	res = f_stat (path, &fd)
-
-	p = strchr(path, ':');
-	if (p == NULL || *++p == '\0' || *p++ != '/')
-		return FR_OK;
-
-	while ((q = strchr(p, '/')) != NULL) {
-		*q = '\0';
-		ret = f_mkdir(path);
-		*q = '/';
-			if (ret != FR_OK && ret != FR_EXIST)
-				return ret;
-		p = q + 1;
-	}
-
-	return FR_OK;
-}
-#endif
-
 /******************************************************************************/
 
-/*
- * These functions manipulate paths in PATH_T structures.
- *
- * They eliminate multiple slashes in paths when they notice them,
- * and keep the path non-slash terminated.
- *
- * Both path_set() and path_append() return 0 if the requested name
- * would be too long.
- */
-
-
-typedef struct {
-	char *p_end;			/* pointer to NULL at end of path */
-	char p_path[MAX_PATHLEN + 1];	/* pointer to the start of a path */
-} PATH_T;
-
-static void strip_trailing_slash(PATH_T *p)
-{
-	while (p->p_end > p->p_path && p->p_end[-1] == '/')
-		*--p->p_end = '\0';
-}
-
-/*
- * Move specified string into path.  Convert "" to "." to handle BSD
- * semantics for a null path.  Strip trailing slashes.
- */
-int
-path_set(PATH_T *p, char *string)
-{
-	if (strlen(string) > MAX_PATHLEN) {
-		err(PSTR("%s: name too long"), string);
-		return 0;
-	}
-
-	(void)strcpy(p->p_path, string);
-	p->p_end = p->p_path + strlen(p->p_path);
-
-	if (p->p_path == p->p_end) {
-		*p->p_end++ = '.';
-		*p->p_end = 0;
-	}
-
-	strip_trailing_slash(p);
-	return 1;
-}
-
-/*
- * Append specified string to path, inserting '/' if necessary.  Return a
- * pointer to the old end of path for restoration.
- */
-char *
-path_append(PATH_T *p, char *name, int len)
-{
-	char *old;
-
-	old = p->p_end;
-	if (len == -1)
-		len = strlen(name);
-
-	/* The "+ 1" accounts for the '/' between old path and name. */
-	if ((len + p->p_end - p->p_path + 1) > MAX_PATHLEN) {
-		err(PSTR("%s/%s: name too long"), p->p_path, name);
-		return(0);
-	}
-
-	/*
-	 * This code should always be executed, since paths shouldn't
-	 * end in '/'.
-	 */
-	if (p->p_end[-1] != '/') {
-		*p->p_end++ = '/';
-		*p->p_end = 0;
-	}
-
-	(void)strncat(p->p_end, name, len);
-	p->p_end += len;
-	*p->p_end = 0;
-
-	strip_trailing_slash(p);
-	return(old);
-}
-
-/*
- * Restore path to previous value.  (As returned by path_append.)
- */
-void
-path_restore(p, old)
-	PATH_T *p;
-	char *old;
-{
-	p->p_end = old;
-	*p->p_end = 0;
-}
-
-/*
- * Return basename of path.
- */
-char *
-path_basename(p)
-	PATH_T *p;
-{
-	char *basename;
-
-	basename = strrchr(p->p_path, '/');
-	return(basename ? basename + 1 : p->p_path);
-}
-
-
-uint8_t flags = 0;
-PATH_T *from;
-PATH_T *to;
-
-#define R_FLAG	(1<<0)
-#define I_FLAG	(1<<1)
-#define N_FLAG	(1<<2)
-#define F_FLAG	(1<<3)
-#define P_FLAG	(1<<4)
-#define V_FLAG	(1<<5)
-
 static void
-setfile(FILINFO *fs, FIL *fd)
+setfile(FILINFO *fs)
 {
-	(void) fs;(void) fd;
-#if 0 /* TODO: */
-	static struct timeval tv[2];
+	FRESULT fr;
 
-	fs->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;
+	fr = f_utime(to.p_path, fs);
+	if (fr != FR_OK)
+		err(PSTR("f_utime: %s: %S"), to.p_path, rctostr(fr));
+	fr = f_chmod(to.p_path, fs->fattrib, AM_RDO|AM_ARC|AM_SYS|AM_HID);
+	if (fr != FR_OK)
+		err(PSTR("f_chmod: %s: %S"), to.p_path, rctostr(fr));
 
-	tv[0].tv_sec = fs->st_atime;
-	tv[1].tv_sec = fs->st_mtime;
-	if (utimes(to->p_path, tv))
-		err(PSTR("utimes: %s: %s"), to->p_path, strerror(errno));
-#endif
 }
 
 void copy_file(FILINFO *fs, uint_fast8_t dne)
 {
-	static char buf[MAXBSIZE];
 	FIL from_fd, to_fd;
 	UINT rcount, wcount;
-	//FILINFO to_stat;
-	//char *p;
 	FRESULT fr;
+	BYTE open_mode;
+
+	if (blockbuf == NULL) {
+		blockbuf_size = get_freemem() / 512 * 512;
+		if (blockbuf_size != 0)
+			blockbuf = (uint8_t *) malloc(blockbuf_size);
+		if (blockbuf == NULL) {
+			err(PSTR("Not enough memory!\n"));
+			return;
+		}
+	}
+
+debug_cp("==== copy_file(): dne: %u, blockbuf_size: %d, freemem: %u\n", dne, blockbuf_size, get_freemem());
+debug_cp("     from:'%s'  to:'%s'\n", from.p_path, to.p_path);
 
-debug("==== copy_file(): dne: %u\n", dne);
-debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
 
-	if ((fr = f_open(&from_fd, from->p_path, FA_READ)) != FR_OK) {
-		err(PSTR("%s: %S"), from->p_path, rctostr(fr));
+	if ((fr = f_open(&from_fd, from.p_path, FA_READ)) != FR_OK) {
+		err(PSTR("%s: %S"), from.p_path, rctostr(fr));
 		return;
 	}
 
 	/*
 	 * If the file exists and we're interactive, verify with the user.
-	 * If the file DNE, set the mode to be the from file, minus setuid
-	 * bits, modified by the umask; arguably wrong, but it makes copying
-	 * executables work right and it's been that way forever.  (The
-	 * other choice is 666 or'ed with the execute bits on the from file
-	 * modified by the umask.)
 	 */
 	if (!dne) {
-		if (flags & I_FLAG) {
-			int checkch, ch;
-
-			printf_P(PSTR("overwrite %s? "), to->p_path);
-			checkch = ch = getchar();
-			while (ch != '\n' && ch != EOF)
-				ch = getchar();
-			if (checkch != 'y') {
+		if (flags & N_FLAG) {
+			if (flags & V_FLAG)
+				printf_P(PSTR("%s not overwritten\n"), to.p_path);
+			f_close(&from_fd);
+			return;
+		} if (flags & I_FLAG) {
+			printf_P(PSTR("overwrite '%s'? "), to.p_path);
+			if (!confirm_yes()) {
 				f_close(&from_fd);
 				return;
 			}
 		}
-		fr = f_open(&to_fd, to->p_path, FA_WRITE|FA_CREATE_ALWAYS);
-	} else
-		fr = f_open(&to_fd, to->p_path, FA_WRITE|FA_CREATE_NEW);
+		if (flags & F_FLAG) {
+			/* Remove existing destination file name create a new file. */
+			f_chmod(to.p_path,0, AM_RDO);
+			f_unlink(to.p_path);
+			open_mode = FA_WRITE|FA_CREATE_NEW;
+		} else {
+			/* Overwrite existing destination file name. */
+			open_mode = FA_WRITE|FA_CREATE_ALWAYS;
+		}
+	} else {
+		open_mode = FA_WRITE|FA_CREATE_NEW;
+	}
+	fr = f_open(&to_fd, to.p_path, open_mode);
 
 	if (fr != FR_OK) {
-		err(PSTR("%s: %S"), to->p_path, rctostr(fr));
+		err(PSTR("%s: %S"), to.p_path, rctostr(fr));
 		f_close(&from_fd);
 		return;
 	}
 
-	while ((fr = f_read(&from_fd, buf, MAXBSIZE, &rcount)) == FR_OK &&
+	while ((fr = f_read(&from_fd, blockbuf, blockbuf_size, &rcount)) == FR_OK &&
 											rcount > 0) {
-		fr = f_write(&to_fd, buf, rcount, &wcount);
+		fr = f_write(&to_fd, blockbuf, rcount, &wcount);
 		if (fr || wcount < rcount) {
-			err(PSTR("%s: %S"), to->p_path, rctostr(fr));
+			err(PSTR("%s: %S"), to.p_path, rctostr(fr));
 			break;
 		}
 	}
 	if (fr != FR_OK)
-		err(PSTR("%s: S"), from->p_path, rctostr(fr));
-
-	if (flags & P_FLAG)
-		setfile(fs, &to_fd);
+		err(PSTR("%s: S"), from.p_path, rctostr(fr));
 
 	f_close(&from_fd);
 	if ((fr = f_close(&to_fd)) != FR_OK)
-		err(PSTR("%s: %S"), to->p_path, rctostr(fr));
+		err(PSTR("%s: %S"), to.p_path, rctostr(fr));
+
+	if (flags & P_FLAG)
+		setfile(fs);
 }
 
-#if 1
+static void copy();
+
 static void copy_dir(void)
 {
-debug("==== copy_dir()");
-debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
+	DIR Dir;					/* Directory object */
+	FILINFO Finfo;
+	char *old_from, *old_to;
+	FRESULT res;
+	char *pattern = {"*"};
+
+debug_cp("==== copy_dir(): freemem: %u\n", get_freemem());
+debug_cp("     from:'%s'  to:'%s'\n", from.p_path, to.p_path);
+
+#if 0
 
 	printf_P(PSTR("directory copy not supported, ommitting dir '%s'\n"),
 		from->p_path);
 	command_ret = CMD_RET_FAILURE;
-}
-#else
-static void copy_dir(void)
-{
-	FILINFO from_stat;
-	struct dirent *dp, **dir_list;
-	int dir_cnt, i;
-	char *old_from, *old_to;
 
-debug("==== copy_file(): dne: %u\n", dne);
-debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
+#else
 
-	dir_cnt = scandir(from->p_path, &dir_list, NULL, NULL);
-	if (dir_cnt == -1) {
-		(void)fprintf(stderr, "%s: can't read directory %s.\n",
-		    progname, from->p_path);
-		command_ret = CMD_RET_FAILURE;
-	}
+	for (res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+		 res == FR_OK && Finfo.fname[0];
+		 res = f_findnext(&Dir, &Finfo)) {
 
-	/*
-	 * Instead of handling directory entries in the order they appear
-	 * on disk, do non-directory files before directory files.
-	 * There are two reasons to do directories last.  The first is
-	 * efficiency.  Files tend to be in the same cylinder group as
-	 * their parent, whereas directories tend not to be.  Copying files
-	 * all at once reduces seeking.  Second, deeply nested tree's
-	 * could use up all the file descriptors if we didn't close one
-	 * directory before recursivly starting on the next.
-	 */
-	/* copy files */
-	for (i = 0; i < dir_cnt; ++i) {
-		dp = dir_list[i];
-		if (dp->d_namlen <= 2 && dp->d_name[0] == '.'
-		    && (dp->d_name[1] == NULL || dp->d_name[1] == '.'))
-			goto done;
-		if (!(old_from =
-		    path_append(&from, dp->d_name, (int)dp->d_namlen)))
-			goto done;
-
-		if (statfcn(from->p_path, &from_stat) < 0) {
-			err(PSTR("%s: %s"), dp->d_name, strerror(errno));
-			path_restore(&from, old_from);
-			goto done;
-		}
-		if (S_ISDIR(from_stat.st_mode)) {
+		if (!(Finfo.fattrib & AM_DIR) &&
+				(old_from = path_append(&from, Finfo.fname))) {
+			if ((old_to = path_append(&to, Finfo.fname))) {
+				copy();
+				path_restore(&to, old_to);
+			}
 			path_restore(&from, old_from);
-			continue;
 		}
-		if (old_to = path_append(&to, dp->d_name, (int)dp->d_namlen)) {
-			copy();
-			path_restore(&to, old_to);
-		}
-		path_restore(&from, old_from);
-done:		dir_list[i] = NULL;
-		free(dp);
 	}
 
-	/* copy directories */
-	for (i = 0; i < dir_cnt; ++i) {
-		dp = dir_list[i];
-		if (!dp)
-			continue;
-		if (!(old_from =
-		    path_append(&from, dp->d_name, (int)dp->d_namlen))) {
-			free(dp);
-			continue;
-		}
-		if (!(old_to =
-		    path_append(&to, dp->d_name, (int)dp->d_namlen))) {
-			free(dp);
+	for (res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+		 res == FR_OK && Finfo.fname[0];
+		 res = f_findnext(&Dir, &Finfo)) {
+
+		if ((Finfo.fattrib & AM_DIR) &&
+				(old_from = path_append(&from, Finfo.fname))) {
+			if ((old_to = path_append(&to, Finfo.fname))) {
+				copy();
+				path_restore(&to, old_to);
+			}
 			path_restore(&from, old_from);
-			continue;
 		}
-		copy();
-		free(dp);
-		path_restore(&from, old_from);
-		path_restore(&to, old_to);
 	}
-	free(dir_list);
 }
 #endif
 
@@ -718,22 +942,22 @@ static void copy()
 	uint_fast8_t dne;
 	FRESULT fr;
 
-debug("==== copy()\n");
-debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
+debug_cp("==== copy(); freemem: %u\n", get_freemem());
+debug_cp("     from:'%s'  to:'%s'\n", from.p_path, to.p_path);
 
-	fr = f_stat(from->p_path, &from_stat);
+	fr = f_stat(from.p_path, &from_stat);
 	if (fr != FR_OK) {
-		err(PSTR("%s: %S"), from->p_path, rctostr(fr));
+		err(PSTR("%s: %S"), from.p_path, rctostr(fr));
 		return;
 	}
 
 	/* not an error, but need to remember it happened */
-	if (f_stat(to->p_path, &to_stat) != FR_OK)
+	if (f_stat(to.p_path, &to_stat) != FR_OK)
 		dne = 1;
 	else {
-		if (strcmp(to->p_path, from->p_path) == 0) {
+		if (strcmp(to.p_path, from.p_path) == 0) {
 			(void)printf_P(PSTR("%s and %s are identical (not copied).\n"),
-					to->p_path, from->p_path);
+					to.p_path, from.p_path);
 			command_ret = CMD_RET_FAILURE;
 			return;
 		}
@@ -743,7 +967,7 @@ debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
 	if(from_stat.fattrib & AM_DIR) {
 		if (!(flags & R_FLAG)) {
 			(void)printf_P(PSTR("-r not specified; ommitting dir '%s'\n"),
-			    from->p_path);
+			    from.p_path);
 			command_ret = CMD_RET_FAILURE;
 			return;
 		}
@@ -751,27 +975,18 @@ debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
 			/*
 			 * If the directory doesn't exist, create the new one.
 			 */
-			if ((fr = f_mkdir(to->p_path)) != FR_OK) {
-				err(PSTR("%s: %S"), to->p_path, rctostr(fr));
+			if ((fr = f_mkdir(to.p_path)) != FR_OK) {
+				err(PSTR("%s: %S"), to.p_path, rctostr(fr));
 				return;
 			}
-		}
-		else if (!(to_stat.fattrib & AM_DIR)) {
-			(void)printf_P(PSTR("%s: not a directory.\n"), to->p_path);
+		} else if (!(to_stat.fattrib & AM_DIR)) {
+			(void)printf_P(PSTR("%s: not a directory.\n"), to.p_path);
 			return;
 		}
 		copy_dir();
-		/*
-		 * If not -p and directory didn't exist, set it to be the
-		 * same as the from directory, umodified by the umask;
-		 * arguably wrong, but it's been that way forever.
-		 */
-#if 0
 		if (flags & P_FLAG)
-			setfile(&from_stat, 0);
-		else if (dne)
-			(void)chmod(to->p_path, from_stat.st_mode);
-#endif
+			setfile(&from_stat);
+
 		return;
 	}
 	copy_file(&from_stat, dne);
@@ -786,57 +1001,54 @@ command_ret_t do_cp(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc,
     char *old_to;
 
 
+	cmdname = argv[0];
+	uint8_t tflags = 0;
 	command_ret = CMD_RET_SUCCESS;
 
 	/* reset getopt() */
 	optind = 0;
 
 	int opt;
-	while ((opt = getopt(argc, argv, PSTR("Rrfip"))) != -1) {
+	while ((opt = getopt(argc, argv, PSTR("finprv"))) != -1) {
 		switch (opt) {
 			case 'f':
-				flags &= I_FLAG;
+				tflags &= ~(I_FLAG | N_FLAG);
+				tflags |=  F_FLAG;
 				break;
 			case 'i':
-				flags |= I_FLAG;
-				flags &= F_FLAG;
+				tflags &= ~(F_FLAG | N_FLAG);
+				tflags |=  I_FLAG;
+				break;
+			case 'n':
+				tflags &= ~(F_FLAG | I_FLAG);
+				tflags |=  N_FLAG;
 				break;
 			case 'p':
-				flags |= P_FLAG;
+				tflags |= P_FLAG;
 				break;
-			case 'R':
 			case 'r':
-				flags |= R_FLAG;
+				tflags |= R_FLAG;
 				break;
 			case 'v':
-				flags |= V_FLAG;
+				tflags |= V_FLAG;
 				break;
 			default:
 				return CMD_RET_USAGE;
 				break;
 		}
 	}
+	flags = tflags;
 	argc -= optind;
 	argv += optind;
 
 	if (argc < 2)
 		return CMD_RET_USAGE;
 
-	from = (PATH_T *) malloc(sizeof(PATH_T));
-	to   = (PATH_T *) malloc(sizeof(PATH_T));
-	if (from == NULL || to == NULL) {
-		printf_P(PSTR("cp: Out of Memory!\n"));
-		command_ret = CMD_RET_FAILURE;
-		goto cleanup;
-	}
-	from->p_end = from->p_path; *from->p_path = '\0';
-	to->p_end = to->p_path; *to->p_path = '\0';
+	path_init();
 
-	/* consume last argument first. */
-	if (!path_set(to, argv[--argc])) {
-		command_ret = CMD_RET_FAILURE;
+	/* last argument is destination */
+	if (!path_set(&to, argv[--argc]))
 		goto cleanup;
-	}
 
 	/*
 	 * Cp has two distinct cases:
@@ -853,12 +1065,13 @@ command_ret_t do_cp(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc,
 	 * In (2), the real target is not directory, but "directory/source".
 	 */
 
-	fr = f_stat(to->p_path, &to_stat);
-debug("==== main, stat to: fr: %d, attr: %02x\n", fr, to_stat.fattrib);
-debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
+	fr = f_stat(to.p_path, &to_stat);
+debug_cp("==== main, stat to: fr: %d, attr: %02x, flags:%02x, freemem: %u\n",
+						fr, to_stat.fattrib, flags, get_freemem());
+debug_cp("     from:'%s'  to:'%s'\n", from.p_path, to.p_path);
 
 	if (fr != FR_OK && fr != FR_NO_FILE && fr != FR_NO_PATH) {
-		err(PSTR("Test1: %s: %S"), to->p_path, rctostr(fr));
+		err(PSTR("Test1: %s: %S"), to.p_path, rctostr(fr));
 		command_ret = CMD_RET_FAILURE;
 		goto cleanup;
 	}
@@ -867,10 +1080,11 @@ debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
 		 * Case (1).  Target is not a directory.
 		 */
 		if (argc > 1) {
-			command_ret = CMD_RET_USAGE;
+			err(PSTR("target '%s' is not a directory"), to.p_path);
+			//command_ret = CMD_RET_USAGE;
 			goto cleanup;
 		}
-		if (!path_set(from, *argv)) {
+		if (!path_set(&from, *argv)) {
 			command_ret = CMD_RET_FAILURE;
 			goto cleanup;
 		}
@@ -881,9 +1095,9 @@ debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
 		 * Case (2).  Target is a directory.
 		 */
 		for (;; ++argv) {
-			if (!path_set(from, *argv))
+			if (!path_set(&from, *argv))
 				continue;
-			if (!(old_to = path_append(to, path_basename(from), -1)))
+			if (!(old_to = path_append(&to, path_basename(&from))))
 				continue;
 			copy();
 			if (!--argc)
@@ -893,23 +1107,20 @@ debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
 	}
 
 cleanup:
-	free(to);
-	free(from);
+	free(blockbuf);
+	blockbuf = NULL;
+	blockbuf_size = 0;
 
 	return command_ret;
 }
 
 #if 0
 		if (flags & V_FLAG)
-			printf_P((PSTR("%s  %s -> %s\n", badcp ? : "ERR:" : "    ", curr->fts_path, to->p_path)));
+			printf_P((PSTR("%s  %s -> %s\n", badcp ? : "ERR:" : "    ", curr->fts_path, to.p_path)));
 
 #endif
 
 
-
-
-
-
 /******************************************************************************/
 
 /*
@@ -938,7 +1149,7 @@ FRESULT scan_files (
 		i = strlen(path);
 		while (((res = f_readdir(&dirs, &statp->Finfo)) == FR_OK) &&
 					statp->Finfo.fname[0]) {
-			if (_FS_RPATH && statp->Finfo.fname[0] == '.')
+			if (FF_FS_RPATH && statp->Finfo.fname[0] == '.')
 				continue;
 			fn = statp->Finfo.fname;
 			if (statp->Finfo.fattrib & AM_DIR) {
@@ -1166,22 +1377,56 @@ CMD_TBL_ITEM(
 	"dev"
 ),
 CMD_TBL_ITEM(
-	pwd,	2,	CTBL_RPT,	do_pwd,
+	pwd,	1,	CTBL_RPT,	do_pwd,
 	"Print name of current/working directory",
 	""
 ),
+CMD_TBL_ITEM(
+	attrib,	CONFIG_SYS_MAXARGS,	0,			do_attrib,
+    "Display or change attributes on a FAT filesystem",
+    "[+-ahrs] files...\n"
+    "\n"
+    "    -    Clear attributes\n"
+    "    +    Set attributes\n"
+    "    a    Archive\n"
+    "    h    Hidden\n"
+    "    r    Read only\n"
+    "    s    System\n"
+    "Display only:\n"
+    "    v    Volume label\n"
+    "    d    Directory\n"
+),
 CMD_TBL_ITEM(
 	cd,		2,	0,			do_cd,
 	"Change the current/working directory.",
 	"path"
 ),
+CMD_TBL_ITEM(
+	rm,		CONFIG_SYS_MAXARGS,	0,			do_rm,
+	"Remove FILE(s)",
+	"[OPTION]... [FILE]...\n"
+	//"    -i prompt before removal\n"
+	"    -v explain what is being done\n"
+	"\n"
+	"rm does not remove directories."
+),
+CMD_TBL_ITEM(
+	rmdir,		CONFIG_SYS_MAXARGS,	0,			do_rmdir,
+	"Remove the DIRECTORY(ies), if they are empty",
+	"[OPTION]... DIRECTORY..."
+),
+CMD_TBL_ITEM(
+	mkdir,		CONFIG_SYS_MAXARGS,	0,			do_mkdir,
+	"Create the DIRECTORY(ies), if they do not already exist.",
+	"[OPTION]... DIRECTORY..."
+),
 CMD_TBL_ITEM(
 	ls,		2,	CTBL_RPT,	do_ls,
 	"Directory listing",
 	"path"
 ),
 CMD_TBL_ITEM(
-	tst,	2,	CTBL_DBG|CTBL_RPT,	do_tst,
+	tst,	3,	CTBL_DBG|CTBL_RPT,	do_tst,
 	"FatFS test function",
 	"path"
 ),
@@ -1207,8 +1452,16 @@ CMD_TBL_ITEM(
 CMD_TBL_ITEM(
 	cp,	CONFIG_SYS_MAXARGS,	CTBL_DBG,	do_cp,
 	"copy files",
-	"[-R] [-f | -i | -n] [-aprv] source_file target_file\n"
-	"    - \n"
+	"[-f | -i | -n] [-prv] source_file target_file\n"
+//	"[-f | -i | -n] [-prv] source_file target_file\n"
+//	"cp [-f | -i | -n] [-prv] source_file ... target_dir\n"
+	"    -f overwrite existing file ignoring write protection\n"
+	"       this option is ignored when the -n option is also used\n"
+	"    -i prompt before overwrite (overrides a previous -n option)\n"
+	"    -n do not overwrite an existing file (overrides a previous -i option)\n"
+	"    -p preserve attributes and timestamps\n"
+	"    -r copy directories recursively\n"
+	"    -v explain what is being done\n"
 ),
 
 CMD_TBL_ITEM(