wildcards for ls command (*, ?)

[z180-stamp.git] / avr / cmd_fat.c

/*
 * (C) Copyright 2014,2016,2018 Leo C. <erbl259-lmu@yahoo.de>
 *
 * SPDX-License-Identifier:	GPL-2.0
 */

/*
 * FAT filesystem commands
 */

#include "common.h"
#include "cmd_fat.h"
#include <time.h>
uint32_t fat_time(const struct tm * timeptr);

#include "ff.h"
#include "z80-if.h"
#include "eval_arg.h"
#include "con-utils.h"
#include "print-utils.h"
#include "timer.h"
#include "debug.h"
#include "env.h"

#define DEBUG_FA		0	/* 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(fmt, args...)		                                               \
	debug_cond(DEBUG_FA, fmt, ##args)
#define debug_ls(fmt, args...)		                                               \
	debug_cond(DEBUG_LS, fmt, ##args)
#define debug_rm(fmt, args...)		                                               \
	debug_cond(DEBUG_RM, fmt, ##args)


/* TODO: use memory size test function (z80_memsize_detect() ) */
#define MAX_MEMORY	CONFIG_SYS_RAMSIZE_MAX
#define BUFFER_SIZE	FF_MAX_SS
#define PATH_MAX	CONFIG_SYS_MAX_PATHLEN


/*
 * Multible (fat) partitions per physical drive are not supported,
 * but we have up to 2 sdcard slots.
 */
static FATFS FatFs0;
static FATFS FatFs1;

void setup_fatfs(void)
{
	f_mount(&FatFs0, "0:", 0);
	f_mount(&FatFs1, "1:", 0);
}

DWORD get_fattime (void)
{
	time_t timer;
	struct tm tm_timer;

	time(&timer);
	gmtime_r(&timer, &tm_timer);

	return fat_time(&tm_timer);
}


static
bool check_abort(void)
{
	bool ret = ctrlc();

	if (ret)
		printf_P(PSTR("Abort\n"));

	return ret;
}


static const FLASH char * const FLASH rc_strings[] = {
			FSTR("Success"),
			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")
		};


const FLASH char * fat_rctostr(FRESULT rc)
{
	return 	rc < ARRAY_SIZE(rc_strings) ? rc_strings[rc] : PSTR(" Unknown Error");
}

static
void swirl(void)
{
	static const FLASH char swirlchar[] = { '-','\\','|','/' };
	static uint_fast8_t cnt;
	static uint32_t tstamp;

	if (get_timer(0) > tstamp) {
		tstamp = get_timer(0) + 250;
		putchar('\b');
		cnt = (cnt+1) & 3;
		putchar(swirlchar[cnt]);
	}
}

/*
 * 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)
{
	FRESULT res;
	TCHAR buf[PATH_MAX];

	res = f_getcwd(buf, PATH_MAX);  /* Get current directory path */

	if (res != FR_OK)
		cmd_error(CMD_RET_FAILURE, res, NULL);

	puts(buf);

	return CMD_RET_SUCCESS;
}


/*
 * cd - Change the current/working directory.
 *
 */
command_ret_t do_cd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
{
	TCHAR *path;
	FRESULT res = FR_OK;

	if (argc < 2) {
		path = getenv_str(PSTR(ENV_HOME));
		if (path == NULL) {
			cmd_error(CMD_RET_FAILURE, 0, PSTR("\"%S\" not set"), PSTR(ENV_HOME));
		}
	} else
		path = argv[1];

	if (strlen(path) > 1 && path[1] == ':')
		res = f_chdrive(path);

	if (res == FR_OK)
		res = f_chdir(path);

	if (res != FR_OK)
		cmd_error(CMD_RET_FAILURE, res, NULL);

	return CMD_RET_SUCCESS;
}


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' : '-',
				(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);
}

char *path_split(char *p)
{
	if (isdigit(p[0]) && (p[1] == ':'))
		p += 2;

	char *ps = strrchr(p, '/');
	if (ps) {
		if (ps == p) {
			++ps;
			memmove(ps+1, ps, strlen(ps)+1);
		}
		*ps++ = '\0';
	}

	return ps;
}

/*
 * ls path - Directory listing
 *
 */
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 */
	FILINFO finfo;
	unsigned long p1;
	unsigned int s1, s2;
	FRESULT res = FR_OK;
	char buf[PATH_MAX];
	char *path = buf;
	char *pattern;


	memset(buf, 0, PATH_MAX);
	if (argc < 2) {
		buf[0] = '.';
	} else {
		strncpy(path, argv[1], PATH_MAX-1);
	}
	pattern = path_split(path);
	debug_ls("### path, pattern: '%s', '%s'\n", path[0] ? path : "<NULL>", pattern ? pattern : "<NULL>");

	if (pattern == NULL) {
        res = f_opendir(&dir, path);
        if (res == FR_NO_PATH || res == FR_INVALID_NAME) {
			pattern = path;
            path = ".";
        } else if (res != FR_OK) {
			cmd_error(CMD_RET_FAILURE, res, PSTR("'%s'"), path);
        }
    }
	debug_ls("### path, pattern: '%s', '%s'\n", path, pattern ? pattern : "<NULL>");

    if (pattern == NULL || *pattern == '\0')
		pattern = "*";

	debug_ls("### path, pattern: '%s', '%s'\n", path, pattern ? pattern : "<NULL>");

	res = f_findfirst(&dir, &finfo, path, pattern);

	p1 = s1 = s2 = 0;
	for(;;) {
		if (res != FR_OK)
			cmd_error(CMD_RET_FAILURE, res, NULL);
		if (!finfo.fname[0])
			break;
		if (finfo.fattrib & AM_DIR) {
			s2++;
		} else {
			s1++; p1 += finfo.fsize;
		}
		print_dirent(&finfo);
		if (check_abort())
			break;
		res = f_findnext(&dir, &finfo);
	}

	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);
	}

	if (res)
		cmd_error(CMD_RET_FAILURE, res, NULL);

	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 = "";
	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) {
		cmd_error(CMD_RET_FAILURE, ENOMEM, NULL);
	}
	res = f_getcwd(buf, BUFFER_SIZE);  /* Get current directory path */

	if (!res) {
		printf_P(PSTR("cwd: '%s'\n"), buf);
	}
	free(buf);
	if (res)
		cmd_error(CMD_RET_FAILURE, res, NULL);

	if (argc > 1)
		path = argv[1];
	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);
	cmd_error(0, res, NULL);
	if (res == FR_OK) {
		print_dirent(&finfo);
	}

	printf_P(PSTR("==== f_findfirst: "));
	res = f_findfirst(&Dir, &finfo, path, pattern);  /* Start to search for files */
	cmd_error(CMD_RET_FAILURE, res, NULL);
	if (res == FR_OK) {
		print_dirent(&finfo);
	}
	f_closedir(&Dir);

	printf_P(PSTR("==== f_opendir:   "));
	res = f_opendir(&Dir, path);
	cmd_error(CMD_RET_FAILURE, res, NULL);
	f_closedir(&Dir);

	return CMD_RET_SUCCESS;
}

/* 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
)
{
	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 (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;
			}
		}
	}

	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(PATH_MAX);
	if (buf == NULL)
		cmd_error(CMD_RET_FAILURE, ENOMEM, NULL);

	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 FF_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) {
			statp.AccSize = statp.AccFiles = statp.AccDirs = 0;
			strcpy(buf, path);

			my_puts_P(PSTR("\nCounting...  "));
			res = scan_files(buf, &statp);
			putchar('\r');
		}
		if (!res) {
			printf_P(PSTR("%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)
		cmd_error(CMD_RET_FAILURE, res, NULL);

	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_rw(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
{
	FIL File;
	uint32_t addr;
	unsigned long bytes;
	unsigned long pos;
	unsigned long bytes_rw;

	bool dowrite = (argv[0][0] == 'w');
	FRESULT res = FR_OK;
	bool buserr = 0;
	uint32_t timer;
	uint8_t *buffer;

	if (argc < (dowrite ? 4 : 3))
		return CMD_RET_USAGE;

	addr = eval_arg(argv[2], NULL);
	if (addr >= MAX_MEMORY)
		cmd_error(CMD_RET_FAILURE, 0, PSTR("Address too high: %#lx"), addr);

	if (argc > 3)
		bytes = eval_arg(argv[3], NULL);
	else
		bytes = MAX_MEMORY;
	if (argc > 4)
		pos = eval_arg(argv[4], NULL);
	else
		pos = 0;

	if (addr + bytes > MAX_MEMORY)
		bytes = MAX_MEMORY - addr;

	buffer = (uint8_t *) malloc(BUFFER_SIZE);
	if (buffer == NULL)
		cmd_error(CMD_RET_FAILURE, ENOMEM, NULL);

	res = f_open(&File, argv[1], dowrite ? FA_WRITE | FA_CREATE_ALWAYS
										 : FA_READ );

	if (!res) {
		res = f_lseek(&File, pos);
		if (!res) {
			bytes_rw = 0;
			timer = get_timer(0);
			while (bytes) {
				unsigned int cnt, br;

				if (bytes >= BUFFER_SIZE)	{
					cnt = BUFFER_SIZE;
					bytes -= BUFFER_SIZE;
				} else {
					cnt = bytes; bytes = 0;
				}
				if (dowrite) {
					if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
						buserr = 1;
						break;
					}
					z80_read_block(buffer, addr, cnt);
					z80_bus_cmd(Release);
					res = f_write(&File, buffer, cnt, &br);
					if (res != FR_OK)
						break;
				} else {
					res = f_read(&File, buffer, cnt, &br);
					if (res != FR_OK)
						break;
					if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
						buserr = 1;
						break;
					}
					z80_write_block(buffer, addr, br);
					z80_bus_cmd(Release);
				}
				addr += br;

				bytes_rw += br;
				if (cnt != br) {
					if (dowrite)
						printf_P(PSTR("Disk full?\n"));
					break;
				}
				if (check_abort())
					break;
			}

			FRESULT fr = f_close(&File);
			if (!res)
				res = fr;
			timer = get_timer(timer);
			printf_P(PSTR("%lu (%#lx) bytes read/written with %lu bytes/sec.\n"),
						bytes_rw, bytes_rw, timer ? (bytes_rw * 1000 / timer) : 0);
		}
	}

	free(buffer);

	if (res)
		cmd_error(CMD_RET_FAILURE, res, PSTR("'%s'"), argv[1]);
	if (buserr)
		cmd_error(CMD_RET_FAILURE, EBUSTO, NULL);

	return CMD_RET_SUCCESS;
}

/*
 * command table for fat subcommands
 */

cmd_tbl_t cmd_tbl_fat[] = {
CMD_TBL_ITEM(
	status,	2,	CTBL_RPT,	do_stat,
	"Show logical drive status",
	"dev"
),
CMD_TBL_ITEM(
	pwd,	2,	CTBL_RPT|CTBL_SUBCMDAUTO,	do_pwd,
	"Print name of current/working directory",
	""
),
CMD_TBL_ITEM(
	cd,		2,	0|CTBL_SUBCMDAUTO,			do_cd,
	"Change the current/working directory.",
	"path"
),
CMD_TBL_ITEM(
	ls,		2,	CTBL_RPT|CTBL_SUBCMDAUTO,	do_ls,
	"Directory listing",
	"path"
),
CMD_TBL_ITEM(
	tst,	3,	CTBL_DBG|CTBL_RPT,	do_tst,
	"FatFS test function",
	"[path [pattern]]"
),
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(
	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,
	 NULL,
#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;
}