X-Git-Url: http://cloudbase.mooo.com/gitweb/z180-stamp.git/blobdiff_plain/5f7f3586b0444116d5c1340465ecae8d6daa2461..1cdd02d8298159e76a045896abc11a8670504b2a:/avr/cmd_fat.c

diff --git a/avr/cmd_fat.c b/avr/cmd_fat.c
index c5791e5..29d96de 100644
--- a/avr/cmd_fat.c
+++ b/avr/cmd_fat.c
@@ -1,32 +1,49 @@
 /*
- * (C) Copyright 2014 Leo C. <erbl259-lmu@yahoo.de>
+ * (C) Copyright 2014,2016,2018 Leo C. <erbl259-lmu@yahoo.de>
  *
- * SPDX-License-Identifier:	GPL-2.0+
+ * SPDX-License-Identifier:	GPL-2.0
  */
 
 /*
  * FAT filesystem commands
  */
 
-#include "common.h"
-#include <stdlib.h>
-#include <string.h>
-#include <stdbool.h>
+#include "cmd_fat.h"
+#include <util/delay.h>
 
-#include "command.h"
 #include "ff.h"
 #include "z80-if.h"
+#include "eval_arg.h"
 #include "con-utils.h"
 #include "print-utils.h"
 #include "time.h"
 #include "timer.h"
 #include "debug.h"
+#include "env.h"
+#include "getopt-min.h"
 
-/* TODO: use memory size test function (cmd_mem.c) */
-#define MAX_MEMORY	(1ul << 19)
+/* 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 */
 
 
+/*
+ * Multible (fat) partitions per physical drive are not supported,
+ * but we have up to 2 sdcard slots.
+ */
+FATFS FatFs0;
+FATFS FatFs1;
+
+command_ret_t command_ret;
+
+void setup_fatfs(void)
+{
+	f_mount(&FatFs0, "0:", 0);
+	f_mount(&FatFs1, "1:", 0);
+}
+
 DWORD get_fattime (void)
 {
 	time_t timer;
@@ -50,6 +67,29 @@ static bool check_abort(void)
 }
 
 
+static const FLASH char * const FLASH rc_strings[] = {
+			FSTR("OK"),
+			FSTR("disk error"),
+			FSTR("internal error"),
+			FSTR("not ready"),
+			FSTR("no file"),
+			FSTR("no path"),
+			FSTR("invalid name"),
+			FSTR("denied"),
+			FSTR("exist"),
+			FSTR("invalid object"),
+			FSTR("write protected"),
+			FSTR("invalid drive"),
+			FSTR("not enabled"),
+			FSTR("no file system"),
+			FSTR("mkfs aborted"),
+			FSTR("timeout"),
+			FSTR("locked"),
+			FSTR("not enough core"),
+			FSTR("too many open files"),
+			FSTR("invalid parameter")
+		};
+
 static const FLASH char * const FLASH rc_names[] = {
 			FSTR("OK"),
 			FSTR("DISK_ERR"),
@@ -69,24 +109,42 @@ static const FLASH char * const FLASH rc_names[] = {
 			FSTR("TIMEOUT"),
 			FSTR("LOCKED"),
 			FSTR("NOT_ENOUGH_CORE"),
-			FSTR("TOO_MANY_OPEN_FILES")
+			FSTR("TOO_MANY_OPEN_FILES"),
+			FSTR("INVALID_PARAMETER")
 		};
 
 static
 void put_rc (FRESULT rc)
 {
-	if (rc < ARRAY_SIZE(rc_names)) {
 #if GCC_BUG_61443
-		printf_P(PSTR("rc=%u FR_"), rc);
-		my_puts_P(rc_names[rc]);
-		my_puts_P(PSTR("\n"));
+	printf_P(PSTR("rc=%u FR_"), rc);
+	my_puts_P(rc < ARRAY_SIZE(rc_names) ? rc_names[rc] : PSTR(" Unknown Error"));
+	my_puts_P(PSTR("\n"));
 #else
-		printf_P(PSTR("rc=%u FR_%S\n"), rc, rc_names[rc]);
+	printf_P(PSTR("rc=%u FR_%S\n"), rc,
+	rc < ARRAY_SIZE(rc_names) ? rc_names[rc] : PSTR(" Unknown Error"));
 #endif
-	}
+}
+
+const FLASH char * rctostr(FRESULT rc)
+{
+	return 	rc < ARRAY_SIZE(rc_strings) ? rc_strings[rc] : PSTR(" Unknown Error");
+}
+
+void err(const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+//	(void)fprintf(stderr, "%s: ", progname);
+	(void)vfprintf_P(stdout, fmt, ap);
+	va_end(ap);
+	(void)printf_P(PSTR("\n"));
+	_delay_ms(20);
+	command_ret = CMD_RET_FAILURE;
 }
 
 
+
 static void swirl(void)
 {
 	static const FLASH char swirlchar[] = { '-','\\','|','/' };
@@ -100,129 +158,65 @@ static void swirl(void)
 	}
 }
 
-/* Work register for fs command */
-struct stat_dat_s {
-	DWORD AccSize;
-	WORD  AccFiles, AccDirs;
-	FILINFO Finfo;
-};
-
-static
-FRESULT scan_files (
-	char *path,			/* Pointer to the working buffer with start path */
-	struct stat_dat_s *statp
-)
+/*
+ * pwd - Print current directory of the current drive.
+ *
+ */
+command_ret_t do_pwd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
 {
-	DIR dirs;
 	FRESULT res;
-	int i;
-	char *fn;
+	char *buf;
 
-	res = f_opendir(&dirs, path);
-	swirl();
-	if (res == FR_OK) {
-		i = strlen(path);
-		while (((res = f_readdir(&dirs, &statp->Finfo)) == FR_OK) &&
-					statp->Finfo.fname[0]) {
-			if (_FS_RPATH && statp->Finfo.fname[0] == '.')
-				continue;
-			fn = statp->Finfo.fname;
-			if (statp->Finfo.fattrib & AM_DIR) {
-				statp->AccDirs++;
-				path[i] = '/';
-				strcpy(path+i+1, fn);
-				res = scan_files(path, statp);
-				path[i] = '\0';
-				if (res != FR_OK)
-					break;
-			} else {
-				//printf_P(PSTR("%s/%s\n"), path, fn);
-				statp->AccFiles++;
-				statp->AccSize += statp->Finfo.fsize;
-			}
-			if (check_abort()) {
-				res = 255;
-				break;
-			}
-		}
+	buf = (char *) malloc(BUFFER_SIZE);
+	if (buf == NULL) {
+		printf_P(PSTR("pwd: Out of Memory!\n"));
+		free(buf);
+		return CMD_RET_FAILURE;
 	}
 
-	return res;
+	res = f_getcwd(buf, BUFFER_SIZE);  /* Get current directory path */
+
+	if (!res) {
+		puts(buf);
+	}
+	free(buf);
+	if (res) {
+		put_rc(res);
+		return CMD_RET_FAILURE;
+	}
+	return CMD_RET_SUCCESS;
 }
 
 
 /*
- * fatstat path - Show logical drive status
+ * cd - Change the current/working directory.
  *
  */
-command_ret_t do_fat_stat(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_cd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
 {
-	FATFS *FatFs, *fs;
-	DWORD nfreeclst;
-	FRESULT res;
-	char *path;
-	struct stat_dat_s statp;
+	char *arg;
+	FRESULT res = 0;
 
-	(void) cmdtp; (void) flag; (void) argc;
+	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;
+		}
+	} else
+		arg = argv[1];
 
-	FatFs = (FATFS *) malloc(sizeof (FATFS));
-	path = (char *) malloc(BUFFER_SIZE);
-	if (FatFs == NULL || path == NULL) {
-		printf_P(PSTR("fatstat: Out of Memory!\n"));
-		free(path);
-		free(FatFs);
-		return CMD_RET_FAILURE;
+	if (arg[1] == ':') {
+		char drv[3];
+		drv[2] = '\0';
+		drv[1] = ':';
+		drv[0] = arg[0];
+		res = f_chdrive(drv);
 	}
-
-	res = f_mount(FatFs, argv[1], 0);
 	if (!res) {
-		res = f_getfree(argv[1], &nfreeclst, &fs);
-		if (!res) {
-			printf_P(PSTR(
-						"FAT type:                %u\n"
-						"Bytes/Cluster:           %lu\n"
-						"Number of FATs:          %u\n"
-						"Root DIR entries:        %u\n"
-						"Sectors/FAT:             %lu\n"
-						"Number of clusters:      %lu\n"
-						"FAT start (lba):         %lu\n"
-						"DIR start (lba,cluster): %lu\n"
-						"Data start (lba):        %lu\n"),
-					fs->fs_type, (DWORD)fs->csize * 512, fs->n_fats,
-					fs->n_rootdir, fs->fsize, fs->n_fatent - 2,
-					fs->fatbase, fs->dirbase, fs->database);
-
-#if _USE_LABEL
-			TCHAR label[12];
-			DWORD serial;
-			res = f_getlabel(argv[1], label, &serial);
-			if (!res) {
-				printf_P(PSTR(
-							"Volume name:             %s\n"
-							"Volume S/N:              %04X-%04X\n"),
-						label, (WORD)(serial >> 16), (WORD)(serial & 0xFFFF));
-			}
-#endif
-			if (!res) {
-				my_puts_P(PSTR("\nCounting...  "));
-				statp.AccSize = statp.AccFiles = statp.AccDirs = 0;
-				strcpy(path, argv[1]);
-
-				res = scan_files(path, &statp);
-			}
-			if (!res) {
-				printf_P(PSTR("\r%u files, %lu bytes.\n%u folders.\n"
-							 "%lu KB total disk space.\n%lu KB available.\n"),
-						statp.AccFiles, statp.AccSize, statp.AccDirs,
-						(fs->n_fatent - 2) * (fs->csize / 2), nfreeclst * (fs->csize / 2)
-				);
-			}
-		}
+		res = f_chdir(arg);
 	}
 
-	free(path);
-	free(FatFs);
-	f_mount(NULL, argv[1], 0);
 	if (res) {
 		put_rc(res);
 		return CMD_RET_FAILURE;
@@ -230,65 +224,99 @@ command_ret_t do_fat_stat(cmd_tbl_t *cmdtp, int flag, int argc, char * const arg
 	return CMD_RET_SUCCESS;
 }
 
+#define MAX_PATHLEN CONFIG_SYS_MAX_PATHLEN
 
 /*
- * fatls path - Directory listing
+ * Remove trailing slashes,
+ * but keep a leading slash (absolute path)
+ */
+void strip_trailing_slash_relpath(char *p)
+{
+	int n = strlen(p);
+
+	if (n >= 2 && (p[0] & 0x38) == '0' &&  p[1] == ':') {
+		p += 2;
+		n -= 2;
+	}
+	if (n >= 1 &&  p[0] == '/') {
+		p++;
+		n--;
+	}
+	while (n-- != 0  && p[n] == '/')
+			p[n] = '\0';
+}
+
+int print_dirent(FILINFO *f)
+{
+	return 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' : '-',
+				(f->fattrib & AM_SYS) ? 'S' : '-',
+				(f->fattrib & AM_ARC) ? 'A' : '-',
+				(f->fdate >> 9) + 1980, (f->fdate >> 5) & 15, f->fdate & 31,
+				(f->ftime >> 11), (f->ftime >> 5) & 63,
+				f->fsize, f->fname);
+}
+
+/*
+ * ls path - Directory listing
  *
  */
-command_ret_t do_fat_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_ls(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
 {
-	FATFS FatFs, *fs;
+	FATFS *fs;
 	DIR Dir;					/* Directory object */
 	FILINFO Finfo;
 	unsigned long p1;
 	unsigned int s1, s2;
 	FRESULT res;
-#if _USE_LFN
-	char Lfname[_MAX_LFN+1];
-	Finfo.lfname = Lfname;
-	Finfo.lfsize = sizeof Lfname;
-#endif
 
-	(void) cmdtp; (void) flag; (void) argc;
+	char *path = "";
+	if (argc > 1)
+		path = argv[1];
+	strip_trailing_slash_relpath(path);
 
-	res = f_mount(&FatFs, argv[1], 0);
-	if (!res)
-		res = f_opendir(&Dir, argv[1]);
-	if (res) {
-		put_rc(res);
-		return CMD_RET_FAILURE;
+	char *p = strrchr(path, '/');
+	if (p)
+		p++;
+	else {
+		p = path;
+		char *q = p;
+		if ((*q++ & 0x38) == '0' &&  *q++ == ':')
+			p = q;
 	}
 
+	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);
+
+//printf_P(PSTR("*: |%s| |%s|\n"), path ? path : "<NULL>", pattern ? pattern : "<NULL>");
+
 	p1 = s1 = s2 = 0;
-	for(;;) {
-		res = f_readdir(&Dir, &Finfo);
-		if ((res != FR_OK) || !Finfo.fname[0])
-			break;
+	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;
 		}
-		printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu  "),
-					(Finfo.fattrib & AM_DIR) ? 'D' : '-',
-					(Finfo.fattrib & AM_RDO) ? 'R' : '-',
-					(Finfo.fattrib & AM_HID) ? 'H' : '-',
-					(Finfo.fattrib & AM_SYS) ? 'S' : '-',
-					(Finfo.fattrib & AM_ARC) ? 'A' : '-',
-					(Finfo.fdate >> 9) + 1980, (Finfo.fdate >> 5) & 15, Finfo.fdate & 31,
-					(Finfo.ftime >> 11), (Finfo.ftime >> 5) & 63, Finfo.fsize);
-#if _USE_LFN
-		printf_P(PSTR("%s\n"), *Lfname ? Lfname : Finfo.fname);
-#else
-		printf_P(PSTR("%s\n"), Finfo.fname);
-#endif
+		print_dirent(&Finfo);
 		if (check_abort())
 			break;
+		res = f_findnext(&Dir, &Finfo);
 	}
+	f_closedir(&Dir);
+	free(pattern);
 
 	if (res == FR_OK) {
 		printf_P(PSTR("%4u File(s),%10lu bytes total\n%4u Dir(s)"), s1, p1, s2);
-		if (f_getfree(argv[1], (DWORD*)&p1, &fs) == FR_OK)
+		if (f_getfree(path, (DWORD*)&p1, &fs) == FR_OK)
 			printf_P(PSTR(", %10luK bytes free\n"), p1 * fs->csize / 2);
 	}
 
@@ -300,21 +328,75 @@ command_ret_t do_fat_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[
 	return CMD_RET_SUCCESS;
 }
 
+/*
+ * tst path - for debugging: test access with different functions
+ *
+ */
+command_ret_t do_tst(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+	DIR Dir;					/* Directory object */
+	FILINFO Finfo;
+	FRESULT res = FR_OK;
+	char *path;
+
+	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);
+		return CMD_RET_FAILURE;
+	}
+	res = f_getcwd(buf, BUFFER_SIZE);  /* Get current directory path */
+
+	if (!res) {
+		printf_P(PSTR("cwd: |%s|\n"), buf);
+	}
+	free(buf);
+	if (res) {
+		put_rc(res);
+		return CMD_RET_FAILURE;
+	}
+
+	if (argc > 1)
+		path = argv[1];
+	else
+		path = "";
+
+	printf_P(PSTR("arg: |%s|\n"), path);
+	printf_P(PSTR("==== f_stat:      "));
+	res = f_stat(path, &Finfo);
+	put_rc(res);
+	if (res == FR_OK) {
+		print_dirent(&Finfo);
+	}
+
+	printf_P(PSTR("==== f_findfirst: "));
+	res = f_findfirst(&Dir, &Finfo, path, "*");  /* Start to search for files */
+	put_rc(res);
+	if (res == FR_OK) {
+		print_dirent(&Finfo);
+	}
+	f_closedir(&Dir);
+
+	printf_P(PSTR("==== f_opendir:   "));
+	res = f_opendir(&Dir, path);
+	put_rc(res);
+	f_closedir(&Dir);
+
+	return CMD_RET_SUCCESS;
+}
+
+#if 0
 static
 FRESULT mkpath(TCHAR *path)
 {
 	/* TODO: */
 	(void) path;
-#if 0
 	FILINFO fd
 	TCHAR *p, *q;
 	FRESULT ret;
 
-#if _USE_LFN
-    fd.lfname = 0;
-#endif
-
-
 	res = f_stat (path, &fd)
 
 	p = strchr(path, ':');
@@ -329,69 +411,673 @@ FRESULT mkpath(TCHAR *path)
 				return ret;
 		p = q + 1;
 	}
-#endif
 
 	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("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, 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("append: '%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(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;
+
+	basename = strrchr(p->p_path, '/');
+	return(basename ? basename + 1 : p->p_path);
+}
+
+
+static uint8_t flags;
+PATH_T *from;
+PATH_T *to;
+
+#define R_FLAG	(1<<0)	// copy directories recursively
+#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 F_FLAG	(1<<3)	// if an existing destination file cannot be opened, remove it and try again (this option is ignored when the -n option is also used)
+#define P_FLAG	(1<<4)	// preserve attributes and timestamps
+#define V_FLAG	(1<<5)	// explain what is being done
+
+static void
+setfile(FILINFO *fs, FIL *fd)
+{
+	(void) fs;(void) fd;
+#if 0 /* TODO: */
+	static struct timeval tv[2];
+
+	fs->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;
+
+	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;
+
+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));
+		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) {
+			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 (fr != FR_OK) {
+		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 &&
+											rcount > 0) {
+		fr = f_write(&to_fd, buf, rcount, &wcount);
+		if (fr || wcount < rcount) {
+			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);
+
+	f_close(&from_fd);
+	if ((fr = f_close(&to_fd)) != FR_OK)
+		err(PSTR("%s: %S"), to->p_path, rctostr(fr));
+}
+
+#if 1
+static void copy_dir(void)
+{
+debug("==== copy_dir()");
+debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
+
+	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);
+
+	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;
+	}
+
+	/*
+	 * 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)) {
+			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);
+			path_restore(&from, old_from);
+			continue;
+		}
+		copy();
+		free(dp);
+		path_restore(&from, old_from);
+		path_restore(&to, old_to);
+	}
+	free(dir_list);
+}
+#endif
+
+/*
+ * copy file or directory at "from" to "to".
+ */
+static void copy()
+{
+	FILINFO from_stat, to_stat;
+	uint_fast8_t dne;
+	FRESULT fr;
+
+debug("==== copy()\n");
+debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);
+
+	fr = f_stat(from->p_path, &from_stat);
+	if (fr != FR_OK) {
+		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)
+		dne = 1;
+	else {
+		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);
+			command_ret = CMD_RET_FAILURE;
+			return;
+		}
+		dne = 0;
+	}
+
+	if(from_stat.fattrib & AM_DIR) {
+		if (!(flags & R_FLAG)) {
+			(void)printf_P(PSTR("-r not specified; ommitting dir '%s'\n"),
+			    from->p_path);
+			command_ret = CMD_RET_FAILURE;
+			return;
+		}
+		if (dne) {
+			/*
+			 * 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));
+				return;
+			}
+		}
+		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
+		return;
+	}
+	copy_file(&from_stat, dne);
+}
+
+command_ret_t do_cp(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+
+    FRESULT fr;     	/* Return value */
+    //DIR dj;        		/* Directory search object */
+    FILINFO to_stat;    /* File information */
+    char *old_to;
+
+
+	uint8_t tflags = 0;
+	command_ret = CMD_RET_SUCCESS;
+
+	/* reset getopt() */
+	optind = 0;
+
+	int opt;
+	while ((opt = getopt(argc, argv, PSTR("rfipv"))) != -1) {
+		switch (opt) {
+			case 'f':
+				tflags &= ~I_FLAG;
+				tflags |=  F_FLAG;
+				break;
+			case 'i':
+				tflags &= ~F_FLAG;
+				tflags |=  I_FLAG;
+				break;
+			case 'p':
+				tflags |= P_FLAG;
+				break;
+			case 'r':
+				tflags |= R_FLAG;
+				break;
+			case 'v':
+				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';
+
+	/* consume last argument first. */
+	if (!path_set(to, argv[--argc])) {
+		command_ret = CMD_RET_FAILURE;
+		goto cleanup;
+	}
+
+	/*
+	 * Cp has two distinct cases:
+	 *
+	 * % cp [-rip] source target
+	 * % cp [-rip] source1 ... directory
+	 *
+	 * In both cases, source can be either a file or a directory.
+	 *
+	 * In (1), the target becomes a copy of the source. That is, if the
+	 * source is a file, the target will be a file, and likewise for
+	 * directories.
+	 *
+	 * 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, flags:%02x\n", fr, to_stat.fattrib, flags);
+debug("     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));
+		command_ret = CMD_RET_FAILURE;
+		goto cleanup;
+	}
+	if (!(fr == FR_OK && (to_stat.fattrib & AM_DIR))) {
+		/*
+		 * Case (1).  Target is not a directory.
+		 */
+		if (argc > 1) {
+			err(PSTR("target '%s' is not a directory"), to->p_path);
+			//command_ret = CMD_RET_USAGE;
+			goto cleanup;
+		}
+		if (!path_set(from, *argv)) {
+			command_ret = CMD_RET_FAILURE;
+			goto cleanup;
+		}
+		copy();
+	}
+	else {
+		/*
+		 * Case (2).  Target is a directory.
+		 */
+		for (;; ++argv) {
+			if (!path_set(from, *argv))
+				continue;
+			if (!(old_to = path_append(to, path_basename(from), -1)))
+				continue;
+			copy();
+			if (!--argc)
+				break;
+			path_restore(to, old_to);
+		}
+	}
+
+cleanup:
+	free(to);
+	free(from);
+
+	return command_ret;
+}
+
+#if 0
+		if (flags & V_FLAG)
+			printf_P((PSTR("%s  %s -> %s\n", badcp ? : "ERR:" : "    ", curr->fts_path, to->p_path)));
+
+#endif
+
+
+
+
+
+
+/******************************************************************************/
+
+/*
+ * Work register for stat command
+ */
+struct stat_dat_s {
+	DWORD AccSize;
+	WORD  AccFiles, AccDirs;
+	FILINFO Finfo;
+};
+
+static
+FRESULT scan_files (
+	char *path,			/* Pointer to the working buffer with start path */
+	struct stat_dat_s *statp
+)
+{
+	DIR dirs;
+	FRESULT res;
+	int i;
+	char *fn;
+
+	res = f_opendir(&dirs, path);
+	swirl();
+	if (res == FR_OK) {
+		i = strlen(path);
+		while (((res = f_readdir(&dirs, &statp->Finfo)) == FR_OK) &&
+					statp->Finfo.fname[0]) {
+			if (_FS_RPATH && statp->Finfo.fname[0] == '.')
+				continue;
+			fn = statp->Finfo.fname;
+			if (statp->Finfo.fattrib & AM_DIR) {
+				statp->AccDirs++;
+				path[i] = '/';
+				strcpy(path+i+1, fn);
+				res = scan_files(path, statp);
+				path[i] = '\0';
+				if (res != FR_OK)
+					break;
+			} else {
+				//printf_P(PSTR("%s/%s\n"), path, fn);
+				statp->AccFiles++;
+				statp->AccSize += statp->Finfo.fsize;
+			}
+			if (check_abort()) {
+				res = 255;
+				break;
+			}
+		}
+	}
+
+	return res;
+}
+
+
+/*
+ * fatstat path - Show logical drive status
+ *
+ */
+command_ret_t do_stat(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+	FATFS *fs;
+	DWORD nfreeclst;
+	FRESULT res;
+	char *buf;
+	char *path = "";
+	struct stat_dat_s statp;
+
+	buf = (char *) malloc(BUFFER_SIZE);
+	if (buf == NULL) {
+		printf_P(PSTR("fat stat: Out of Memory!\n"));
+		return CMD_RET_FAILURE;
+	}
+
+	if (argc > 1)
+		path = argv[1];
+	res = f_getfree(path, &nfreeclst, &fs);
+	if (!res) {
+		printf_P(PSTR(
+					"FAT type:                %u\n"
+					"Bytes/Cluster:           %lu\n"
+					"Number of FATs:          %u\n"
+					"Root DIR entries:        %u\n"
+					"Sectors/FAT:             %lu\n"
+					"Number of clusters:      %lu\n"
+					"FAT start (lba):         %lu\n"
+					"DIR start (lba,cluster): %lu\n"
+					"Data start (lba):        %lu\n"),
+				fs->fs_type, (DWORD)fs->csize * 512, fs->n_fats,
+				fs->n_rootdir, fs->fsize, fs->n_fatent - 2,
+				fs->fatbase, fs->dirbase, fs->database);
+
+#if _USE_LABEL
+		DWORD serial;
+		res = f_getlabel(path, buf, &serial);
+		if (!res) {
+			printf_P(PSTR(
+						"Volume name:             %s\n"
+						"Volume S/N:              %04X-%04X\n"),
+					buf, (WORD)(serial >> 16), (WORD)(serial & 0xFFFF));
+		}
+#endif
+		if (!res) {
+			my_puts_P(PSTR("\nCounting...  "));
+			statp.AccSize = statp.AccFiles = statp.AccDirs = 0;
+			strcpy(buf, path);
+
+			res = scan_files(buf, &statp);
+		}
+		if (!res) {
+			printf_P(PSTR("\r%u files, %lu bytes.\n%u folders.\n"
+						 "%lu KB total disk space.\n%lu KB available.\n"),
+					statp.AccFiles, statp.AccSize, statp.AccDirs,
+					(fs->n_fatent - 2) * (fs->csize / 2), nfreeclst * (fs->csize / 2)
+			);
+		}
+	}
+
+	free(buf);
+	if (res) {
+		put_rc(res);
+		return CMD_RET_FAILURE;
+	}
+	return CMD_RET_SUCCESS;
+}
 
 /*
  * fatread/write - load binary file to/from a dos filesystem
  *		read  <d:/path/filename> <addr> [bytes [pos]]
  *		write <d:/path/filename> <addr> <bytes>
  */
-command_ret_t do_fat_rw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+command_ret_t do_rw(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
 {
-	FATFS *FatFs;
 	FIL File;
 	uint32_t addr;
 	unsigned long bytes;
 	unsigned long pos;
 	unsigned long bytes_rw;
 
-	bool dowrite = (argv[0][3] == 'w');
-	FRESULT res;
+	bool dowrite = (argv[0][0] == 'w');
+	FRESULT res = FR_OK;
 	bool buserr = 0;
 	uint32_t timer;
 	uint8_t *buffer;
 
-	(void) cmdtp; (void) flag;
-
 	if (argc < (dowrite ? 4 : 3))
 		return CMD_RET_USAGE;
 
-	addr = strtoul(argv[2], 0, 16);
+	addr = eval_arg(argv[2], NULL);
 	if (addr >= MAX_MEMORY) {
 		printf_P(PSTR("address too high: 0x%0lx\n"), addr);
 		return CMD_RET_FAILURE;
 	}
 	if (argc > 3)
-		bytes = strtoul(argv[3], 0, 16);
+		bytes = eval_arg(argv[3], NULL);
 	else
 		bytes = MAX_MEMORY;
 	if (argc > 4)
-		pos = strtoul(argv[4], 0, 16);
+		pos = eval_arg(argv[4], NULL);
 	else
 		pos = 0;
 
 	if (addr + bytes > MAX_MEMORY)
 		bytes = MAX_MEMORY - addr;
 
-	FatFs = (FATFS *) malloc(sizeof (FATFS));
 	buffer = (uint8_t *) malloc(BUFFER_SIZE);
-	if (FatFs == NULL || buffer == NULL) {
+	if (buffer == NULL) {
 		printf_P(PSTR("fatstat: Out of Memory!\n"));
-		free(FatFs);
 		free(buffer);
 		return CMD_RET_FAILURE;
 	}
 
-	res = f_mount(FatFs, argv[1], 0);
-
-	if (!res) {
-		if (dowrite) {
-			res = mkpath(argv[1]);
-		}
-	}
 	if (!res) {
 		res = f_open(&File, argv[1], dowrite ? FA_WRITE | FA_CREATE_ALWAYS
 											 : FA_READ );
@@ -451,11 +1137,9 @@ command_ret_t do_fat_rw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[
 							bytes_rw, bytes_rw, timer ? (bytes_rw * 1000 / timer) : 0);
 			}
 		}
-		f_mount(NULL, argv[1], 0);
 	}
 
 	free(buffer);
-	free(FatFs);
 
 	if (buserr)
 		my_puts_P(PSTR("Bus timeout\n"));
@@ -466,3 +1150,98 @@ command_ret_t do_fat_rw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[
 
 	return CMD_RET_SUCCESS;
 }
+
+/*
+ * command table for fat subcommands
+ */
+
+cmd_tbl_t cmd_tbl_fat[] = {
+CMD_TBL_ITEM(
+	stat,	2,	CTBL_RPT,	do_stat,
+	"Show logical drive status",
+	"dev"
+),
+CMD_TBL_ITEM(
+	pwd,	2,	CTBL_RPT,	do_pwd,
+	"Print name of current/working directory",
+	""
+),
+CMD_TBL_ITEM(
+	cd,		2,	0,			do_cd,
+	"Change the current/working directory.",
+	"path"
+),
+CMD_TBL_ITEM(
+	ls,		2,	CTBL_RPT,	do_ls,
+	"Directory listing",
+	"path"
+),
+CMD_TBL_ITEM(
+	tst,	2,	CTBL_DBG|CTBL_RPT,	do_tst,
+	"FatFS test function",
+	"path"
+),
+CMD_TBL_ITEM(
+	load,	5,	0,			do_rw,
+	"load binary file from a dos filesystem",
+	"<d:/path/filename> <addr> [bytes [pos]]\n"
+	"    - Load binary file 'path/filename' on logical drive 'd'\n"
+	"      to address 'addr' from dos filesystem.\n"
+	"      'pos' gives the file position to start loading from.\n"
+	"      If 'pos' is omitted, 0 is used. 'pos' requires 'bytes'.\n"
+	"      'bytes' gives the size to load. If 'bytes' is 0 or omitted,\n"
+	"      the load stops on end of file."
+),
+CMD_TBL_ITEM(
+	write,	4,	0,			do_rw,
+	"write file into a dos filesystem",
+	"<d:/path/filename> <addr> <bytes>\n"
+	"    - Write file to 'path/filename' on logical drive 'd' from RAM\n"
+	"      starting at address 'addr'.\n"
+),
+
+CMD_TBL_ITEM(
+	cp,	CONFIG_SYS_MAXARGS,	CTBL_DBG,	do_cp,
+	"copy files",
+	"[-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(
+	help,	CONFIG_SYS_MAXARGS,	CTBL_RPT,	do_help,
+	"Print sub command description/usage",
+	"\n"
+	"       - print brief description of all sub commands\n"
+	"fat help command ...\n"
+	"       - print detailed usage of sub cmd 'command'"
+),
+
+/* This does not use the CMD_TBL_ITEM macro as ? can't be used in symbol names */
+	{FSTR("?"),   CONFIG_SYS_MAXARGS, 1, do_help,
+	 FSTR("Alias for 'help'"),
+#ifdef  CONFIG_SYS_LONGHELP
+	FSTR(""),
+#endif /* CONFIG_SYS_LONGHELP */
+	NULL,
+#ifdef CONFIG_AUTO_COMPLETE
+	NULL,
+#endif
+},
+/* Mark end of table */
+CMD_TBL_END(cmd_tbl_fat)
+};
+
+
+command_ret_t do_fat(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
+{
+	puts_P(PSTR("Huch?"));
+
+	return CMD_RET_USAGE;
+}