X-Git-Url: http://cloudbase.mooo.com/gitweb/z180-stamp.git/blobdiff_plain/6c7c9c2dd4350e2de9a9054cedcdc0a005175fcd..refs/heads/fatcommands:/avr/cmd_fat.c diff --git a/avr/cmd_fat.c b/avr/cmd_fat.c index 9e3114d..33d6051 100644 --- a/avr/cmd_fat.c +++ b/avr/cmd_fat.c @@ -1,5 +1,5 @@ /* - * (C) Copyright 2014,2016 Leo C. + * (C) Copyright 2014,2016,2018 Leo C. * * SPDX-License-Identifier: GPL-2.0 */ @@ -9,11 +9,8 @@ */ #include "cmd_fat.h" -#include "common.h" -#include -#include +#include -#include "command.h" #include "ff.h" #include "z80-if.h" #include "eval_arg.h" @@ -25,15 +22,64 @@ #include "env.h" #include "getopt-min.h" -/* TODO: use memory size test function (cmd_mem.c) */ -#define MAX_MEMORY (1ul << 19) + +#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 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, + * but we have up to 2 sdcard slots. + */ FATFS FatFs0; FATFS FatFs1; -char chur_drv[3]; +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) +{ + f_mount(&FatFs0, "0:", 0); + f_mount(&FatFs1, "1:", 0); +} DWORD get_fattime (void) { @@ -58,6 +104,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"), @@ -94,180 +163,250 @@ void put_rc (FRESULT rc) #endif } +const FLASH char * rctostr(FRESULT rc) +{ + return rc < ARRAY_SIZE(rc_strings) ? rc_strings[rc] : PSTR(" Unknown Error"); +} -void setup_fatfs(void) +void err(const char *fmt, ...) { - f_mount(&FatFs0, "0:", 0); - f_mount(&FatFs1, "1:", 0); + va_list ap; + va_start(ap, fmt); + printf_P(PSTR("fat %s: "), cmdname); + vfprintf_P(stdout, fmt, ap); + va_end(ap); + printf_P(PSTR("\n")); + _delay_ms(20); + command_ret = CMD_RET_FAILURE; } +/******************************************************************************/ -static void swirl(void) +/* + * 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) { - static const FLASH char swirlchar[] = { '-','\\','|','/' }; - static uint_fast8_t cnt; - static uint32_t tstamp; + from.p_path[0] = '\0'; from.p_end = from.p_path; + to.p_path[0] = '\0'; to.p_end = to.p_path; +} - if (get_timer(0) > tstamp) { - printf_P(PSTR("\b%c"), swirlchar[cnt]); - cnt = (cnt+1) % ARRAY_SIZE(swirlchar); - tstamp = get_timer(0) + 250; +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; } -/* Work register for fs command */ -struct stat_dat_s { - DWORD AccSize; - WORD AccFiles, AccDirs; - FILINFO Finfo; -}; +static void strip_trailing_slash(PATH_T *p) +{ + char *beg = path_skip_heading(p->p_path); + char *end = p->p_end; -static -FRESULT scan_files ( - char *path, /* Pointer to the working buffer with start path */ - struct stat_dat_s *statp -) + 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) { - DIR dirs; - FRESULT res; - int i; - char *fn; + if (strlen(string) > MAX_PATHLEN) { + err(PSTR("set: '%s': name too long"), string); + return 0; + } - 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; - } - } + (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'; } - return res; + strip_trailing_slash(p); + return 1; } - /* - * fatstat path - Show logical drive status - * + * Append specified string to path, inserting '/' if necessary. Return a + * pointer to the old end of path for restoration. */ -command_ret_t do_stat(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) +char * +path_append(PATH_T *p, char *name) { - FATFS *fs; - DWORD nfreeclst; - FRESULT res; - char *buf; - char *path = ""; - struct stat_dat_s statp; + char *old = p->p_end; + int len = strlen(name); - (void) cmdtp; (void) flag; (void) argc; + /* 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; + } - buf = (char *) malloc(BUFFER_SIZE); - if (buf == NULL) { - printf_P(PSTR("fat stat: Out of Memory!\n")); - return CMD_RET_FAILURE; + /* + * This code should always be executed, since paths shouldn't + * end in '/'. + */ + if (p->p_end[-1] != '/') { + *p->p_end++ = '/'; + *p->p_end = '\0'; } - 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); + strncat(p->p_end, name, len); + p->p_end += len; + *p->p_end = '\0'; -#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)); - } + 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 - 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) - ); - } +/* + * 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' ; - free(buf); - if (res) { - put_rc(res); - return CMD_RET_FAILURE; + 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) +{ + static const FLASH char swirlchar[] = { '-','\\','|','/' }; + static uint_fast8_t cnt; + static uint32_t tstamp; + + if (get_timer(0) > tstamp) { + printf_P(PSTR("\b%c"), swirlchar[cnt]); + cnt = (cnt+1) % ARRAY_SIZE(swirlchar); + tstamp = get_timer(0) + 250; } - return CMD_RET_SUCCESS; } /* * pwd - Print current directory of the current drive. * */ -command_ret_t do_pwd(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) +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; - (void) cmdtp; (void) flag; (void) argc; (void) argv; + cmdname = argv[0]; + command_ret = CMD_RET_SUCCESS; - 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(from.p_path, MAX_PATHLEN); /* Get current directory path */ - res = f_getcwd(buf, BUFFER_SIZE); /* Get current directory path */ + if (res == FR_OK) + puts(from.p_path); + else + err(PSTR("Error: %S"), rctostr(res)); - if (!res) { - puts(buf); - } - free(buf); - if (res) { - put_rc(res); - return CMD_RET_FAILURE; - } - return CMD_RET_SUCCESS; + return command_ret; } @@ -275,64 +414,243 @@ command_ret_t do_pwd(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const * cd - Change the current/working directory. * */ -command_ret_t do_cd(cmd_tbl_t *cmdtp, uint_fast8_t 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[]) { char *arg; - FRESULT res = 0; + FRESULT res = FR_OK; - (void) cmdtp; (void) flag; (void) argc; + 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 255 +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; + } + + 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 : "", pattern ? pattern : ""); + 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; + } } - if (n >= 1 && p[0] == '/') { - p++; - n--; + 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 : "", pattern ? pattern : ""); + + 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; + } } - while (n-- != 0 && p[n] == '/') - p[n] = '\0'; + 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; } -int print_dirent(FILINFO *f) +command_ret_t do_mkdir(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[]) { - return printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu %s\n"), + cmdname = argv[0]; + command_ret = CMD_RET_SUCCESS; + + return command_ret; +} + + +static void print_dirent(FILINFO *f) +{ + 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' : '-', @@ -344,10 +662,10 @@ int print_dirent(FILINFO *f) } /* - * fatls path - Directory listing + * ls path - Directory listing * */ -command_ret_t do_ls(cmd_tbl_t *cmdtp, uint_fast8_t 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 *fs; DIR Dir; /* Directory object */ @@ -355,148 +673,578 @@ command_ret_t do_ls(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const unsigned long p1; unsigned int s1, s2; FRESULT res; - (void) cmdtp; (void) flag; (void) argc; + cmdname = argv[0]; + command_ret = CMD_RET_SUCCESS; + + path_init(); + if (argc > 1) + if (!path_set(&from, argv[1])) { + /* TODO: error out*/ + } + +#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 : "", pattern ? pattern : ""); + + p1 = s1 = s2 = 0; + 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); + + 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(from.p_path, (DWORD*)&p1, &fs) == FR_OK) + printf_P(PSTR(", %10luK bytes free\n"), p1 * fs->csize / 2); + } + + if (res && command_ret == CMD_RET_SUCCESS) { + put_rc(res); + return CMD_RET_FAILURE; + } + + return command_ret; +} +/* + * 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 = ""; + 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("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); + } + free(buf); + if (res) { + put_rc(res); + return CMD_RET_FAILURE; + } + if (argc > 1) path = argv[1]; - strip_trailing_slash_relpath(path); + if (argc > 2) + pattern = argv[2]; + + printf_P(PSTR("arg: '%s' '%s'\n"), path, pattern); + 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, pattern); /* 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; +} + +/******************************************************************************/ + +static void +setfile(FILINFO *fs) +{ + FRESULT fr; + + 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)); + +} + +void copy_file(FILINFO *fs, uint_fast8_t dne) +{ + FIL from_fd, to_fd; + UINT rcount, wcount; + 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); + + + 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 (!dne) { + 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; + } + } + 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)); + f_close(&from_fd); + return; + } + + while ((fr = f_read(&from_fd, blockbuf, blockbuf_size, &rcount)) == FR_OK && + rcount > 0) { + fr = f_write(&to_fd, blockbuf, 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)); + + f_close(&from_fd); + if ((fr = f_close(&to_fd)) != FR_OK) + err(PSTR("%s: %S"), to.p_path, rctostr(fr)); + + if (flags & P_FLAG) + setfile(fs); +} + +static void copy(); + +static void copy_dir(void) +{ + 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 + + 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); + } + } + + 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); + } + } +} +#endif + +/* + * copy file or directory at "from" to "to". + */ +static void copy() +{ + FILINFO from_stat, to_stat; + uint_fast8_t dne; + FRESULT fr; + +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); + 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 (flags & P_FLAG) + setfile(&from_stat); + + 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; + + + cmdname = argv[0]; + uint8_t tflags = 0; + command_ret = CMD_RET_SUCCESS; + + /* reset getopt() */ + optind = 0; + + int opt; + while ((opt = getopt(argc, argv, PSTR("finprv"))) != -1) { + switch (opt) { + case 'f': + tflags &= ~(I_FLAG | N_FLAG); + tflags |= F_FLAG; + break; + case 'i': + tflags &= ~(F_FLAG | N_FLAG); + tflags |= I_FLAG; + break; + case 'n': + tflags &= ~(F_FLAG | I_FLAG); + tflags |= N_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; - char *p = strrchr(path, '/'); - if (p) - p++; - else { - p = path; - char *q = p; - if ((*q++ & 0x38) == '0' && *q++ == ':') - p = q; - } + path_init(); - char *pattern = NULL; - if (strpbrk_P(p, PSTR("*?")) || - (f_stat(path, &Finfo) == FR_OK && !(Finfo.fattrib & AM_DIR))) { - pattern = strdup(p); - *p = '\0'; - } - strip_trailing_slash_relpath(path); + /* last argument is destination */ + if (!path_set(&to, argv[--argc])) + 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". + */ -printf_P(PSTR("*: |%s| |%s|\n"), path ? path : "", pattern ? pattern : ""); + 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); - p1 = s1 = s2 = 0; - res = f_findfirst(&Dir, &Finfo, path, pattern ? pattern : "*"); /* Start to search for files */ - while (res == FR_OK && Finfo.fname[0]) { - if (Finfo.fattrib & AM_DIR) { - s2++; - } else { - s1++; p1 += Finfo.fsize; + 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; } - print_dirent(&Finfo); - if (check_abort()) - break; - res = f_findnext(&Dir, &Finfo); + if (!path_set(&from, *argv)) { + command_ret = CMD_RET_FAILURE; + goto cleanup; + } + copy(); } - 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(path, (DWORD*)&p1, &fs) == FR_OK) - printf_P(PSTR(", %10luK bytes free\n"), p1 * fs->csize / 2); + else { + /* + * Case (2). Target is a directory. + */ + for (;; ++argv) { + if (!path_set(&from, *argv)) + continue; + if (!(old_to = path_append(&to, path_basename(&from)))) + continue; + copy(); + if (!--argc) + break; + path_restore(&to, old_to); + } } - if (res) { - put_rc(res); - return CMD_RET_FAILURE; - } +cleanup: + free(blockbuf); + blockbuf = NULL; + blockbuf_size = 0; - return CMD_RET_SUCCESS; + return command_ret; } -command_ret_t do_tst(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) -{ - DIR Dir; /* Directory object */ - FILINFO Finfo; - FRESULT res = FR_OK; - char *path; - - (void) cmdtp; (void) flag; +#if 0 + if (flags & V_FLAG) + printf_P((PSTR("%s %s -> %s\n", badcp ? : "ERR:" : " ", curr->fts_path, to.p_path))); - printf_P(PSTR("sizeof DIR: %u, sizeof FIL: %u\n"), sizeof (DIR), sizeof (FILINFO)); +#endif - 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 = ""; +/* + * Work register for stat command + */ +struct stat_dat_s { + DWORD AccSize; + WORD AccFiles, AccDirs; + FILINFO Finfo; +}; - 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); - } +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; - printf_P(PSTR("==== f_findfirst: ")); - res = f_findfirst(&Dir, &Finfo, path, "*"); /* Start to search for files */ - put_rc(res); + res = f_opendir(&dirs, path); + swirl(); if (res == FR_OK) { - print_dirent(&Finfo); + i = strlen(path); + while (((res = f_readdir(&dirs, &statp->Finfo)) == FR_OK) && + statp->Finfo.fname[0]) { + if (FF_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; + } + } } - f_closedir(&Dir); - - printf_P(PSTR("==== f_opendir: ")); - res = f_opendir(&Dir, path); - put_rc(res); - f_closedir(&Dir); - return CMD_RET_SUCCESS; + return res; } -static -FRESULT mkpath(TCHAR *path) + +/* + * 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[]) { - /* TODO: */ - (void) path; -#if 0 - FILINFO fd - TCHAR *p, *q; - FRESULT ret; + 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; + } - res = f_stat (path, &fd) + 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); - p = strchr(path, ':'); - if (p == NULL || *++p == '\0' || *p++ != '/') - return FR_OK; +#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); - while ((q = strchr(p, '/')) != NULL) { - *q = '\0'; - ret = f_mkdir(path); - *q = '/'; - if (ret != FR_OK && ret != FR_EXIST) - return ret; - p = q + 1; + 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) + ); + } } -#endif - return FR_OK; + free(buf); + if (res) { + put_rc(res); + return CMD_RET_FAILURE; + } + return CMD_RET_SUCCESS; } /* @@ -504,7 +1252,7 @@ FRESULT mkpath(TCHAR *path) * read [bytes [pos]] * write */ -command_ret_t do_rw(cmd_tbl_t *cmdtp, uint_fast8_t 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[]) { FIL File; uint32_t addr; @@ -518,8 +1266,6 @@ command_ret_t do_rw(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const uint32_t timer; uint8_t *buffer; - (void) cmdtp; (void) flag; - if (argc < (dowrite ? 4 : 3)) return CMD_RET_USAGE; @@ -547,9 +1293,6 @@ command_ret_t do_rw(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const return CMD_RET_FAILURE; } - if (dowrite) { - res = mkpath(argv[1]); - } if (!res) { res = f_open(&File, argv[1], dowrite ? FA_WRITE | FA_CREATE_ALWAYS : FA_READ ); @@ -623,158 +1366,72 @@ command_ret_t do_rw(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const return CMD_RET_SUCCESS; } -/* ========================================================================== */ - - -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 inline 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. + * command table for fat subcommands */ -int -path_set(PATH_T *p, char *string) -{ - if (strlen(string) > MAX_PATHLEN) { - //err("%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); -} - -#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) - -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 fno; /* File information */ - - uint8_t flags = 0; - - - /* reset getopt() */ - optind = 0; - - int opt; - while ((opt = getopt(argc, argv, PSTR("Rrfip"))) != -1) { - switch (opt) { - case 'f': - flags &= I_FLAG; - break; - case 'i': - flags |= I_FLAG; - flags &= F_FLAG; - break; - case 'p': - flags |= P_FLAG; - break; - case 'R': - case 'r': - flags |= R_FLAG; - break; - case 'v': - flags |= V_FLAG; - break; - default: - return CMD_RET_USAGE; - break; - } - } - argc -= optind; - argv += optind; - - if (argc < 2) - return CMD_RET_USAGE; - -#if 0 - /* consume last argument first. */ - if (!path_set(&to, argv[--argc])) - exit(1); - - - if (flags & V_FLAG) - printf_P((PSTR("%s %s -> %s\n", badcp ? : "ERR:" : " ", - curr->fts_path, to.p_path); -#endif - -/* Search a directory for objects and display it */ - - - fr = f_findfirst(&dj, &fno, argv[1], argv[2]); /* Start to search for files */ - - while (fr == FR_OK && fno.fname[0]) { /* Repeat while an item is found */ - printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu %s\n"), - (fno.fattrib & AM_DIR) ? 'D' : '-', - (fno.fattrib & AM_RDO) ? 'R' : '-', - (fno.fattrib & AM_HID) ? 'H' : '-', - (fno.fattrib & AM_SYS) ? 'S' : '-', - (fno.fattrib & AM_ARC) ? 'A' : '-', - (fno.fdate >> 9) + 1980, (fno.fdate >> 5) & 15, fno.fdate & 31, - (fno.ftime >> 11), (fno.ftime >> 5) & 63, - fno.fsize, fno.fname); - fr = f_findnext(&dj, &fno); /* Search for next item */ - } - - f_closedir(&dj); - - return CMD_RET_SUCCESS; -} - cmd_tbl_t cmd_tbl_fat[] = { CMD_TBL_ITEM( - stat, 2, CTBL_REPEAT, do_stat, + stat, 2, CTBL_RPT, do_stat, "Show logical drive status", "dev" ), CMD_TBL_ITEM( - pwd, 2, CTBL_REPEAT, do_pwd, + pwd, 1, CTBL_RPT, do_pwd, "Print name of current/working directory", "" ), CMD_TBL_ITEM( - cd, 2, CTBL_REPEAT, do_cd, + 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( - ls, 2, CTBL_REPEAT, do_ls, + 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_REPEAT, do_tst, + tst, 3, CTBL_DBG|CTBL_RPT, do_tst, "FatFS test function", "path" ), CMD_TBL_ITEM( - load, 5, 0, do_rw, + load, 5, 0, do_rw, "load binary file from a dos filesystem", " [bytes [pos]]\n" " - Load binary file 'path/filename' on logical drive 'd'\n" @@ -785,7 +1442,7 @@ CMD_TBL_ITEM( " the load stops on end of file." ), CMD_TBL_ITEM( - write, 4, 0, do_rw, + write, 4, 0, do_rw, "write file into a dos filesystem", " \n" " - Write file to 'path/filename' on logical drive 'd' from RAM\n" @@ -793,14 +1450,22 @@ CMD_TBL_ITEM( ), CMD_TBL_ITEM( - cp, CONFIG_SYS_MAXARGS, 0, do_cp, + cp, CONFIG_SYS_MAXARGS, CTBL_DBG, do_cp, "copy files", - "cp [-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( - help, CONFIG_SYS_MAXARGS, CTBL_REPEAT, do_help, + help, CONFIG_SYS_MAXARGS, CTBL_RPT, do_help, "Print sub command description/usage", "\n" " - print brief description of all sub commands\n" @@ -824,7 +1489,7 @@ CMD_TBL_END(cmd_tbl_fat) }; -command_ret_t do_fat(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) +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?"));