merge do_fat_read() and do_fat_write() to do_fat_rw()

diff --git a/avr/cmd_fat.c b/avr/cmd_fat.c
index 1c46dd1002f249796d88e00ff3aee24d710967cb..0232f5dab9ddcfda54d36fed77350fa70005e4ed 100644 (file)
--- a/avr/cmd_fat.c
+++ b/avr/cmd_fat.c
@@ -6,13 +6,17 @@
 #include "command.h"
 #include "ff.h"
 #include "z80-if.h"
+#include "con-utils.h"
 #include "print-utils.h"
 #include "timer.h"
 #include "debug.h"
 
 
+#define MAX_MEMORY     (1ul << 20)
+
 DWORD get_fattime (void)
 {
+       /* TODO: */
        return 0;
 }
 
@@ -109,65 +113,70 @@ FRESULT scan_files (
  */
 command_ret_t do_fat_stat(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
-       FATFS FatFs, *fs;
-       DWORD clusters;
+       FATFS *FatFs, *fs;
+       DWORD nfreeclst;
        FRESULT res;
-       char buffer[512];
+       char *buffer;
 
        (void) cmdtp; (void) flag; (void) argc;
 
-       res = f_mount(&FatFs, argv[1], 0);
-       if (!res)
-               res = f_getfree(argv[1], &clusters, &fs);
-       if (res) {
-               put_rc(res);
+       FatFs = (FATFS *) malloc(sizeof (FATFS));
+       buffer = (char *) malloc(512);
+       if (FatFs == NULL || buffer == NULL) {
+               printf_P(PSTR("fatstat: Out of Memory!\n"));
+               free(FatFs);
+               free(buffer);
                return CMD_RET_FAILURE;
        }
 
-       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);
+       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) {
-               put_rc(res);
-               return CMD_RET_FAILURE;
-       }
-       printf_P(PSTR(
-                               "Volume name:             %s\n"
-                               "Volume S/N:              %04X-%04X\n"),
-                       label, (WORD)(serial >> 16), (WORD)(serial & 0xFFFF));
+                       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
-       my_puts_P(PSTR("\n..."));
-       AccSize = AccFiles = AccDirs = 0;
+                       if (!res) {
+                               my_puts_P(PSTR("\n..."));
+                               AccSize = AccFiles = AccDirs = 0;
 
-       strcpy(buffer, argv[1]);
+                               strcpy(buffer, argv[1]);
 
-       res = scan_files(buffer);
-       if (res) {
-               put_rc(res);
-               return CMD_RET_FAILURE;
+                               res = scan_files(buffer);
+                       }
+                       if (!res) {
+                               printf_P(PSTR("\r%u files, %lu bytes.\n%u folders.\n"
+                                                        "%lu KB total disk space.\n%lu KB available.\n"),
+                                               AccFiles, AccSize, AccDirs,
+                                               (fs->n_fatent - 2) * (fs->csize / 2), nfreeclst * (fs->csize / 2)
+                               );
+                       }
+               }
        }
-       printf_P(PSTR("\r%u files, %lu bytes.\n%u folders.\n"
-                                "%lu KB total disk space.\n%lu KB available.\n"),
-                       AccFiles, AccSize, AccDirs,
-                       (fs->n_fatent - 2) * (fs->csize / 2), clusters * (fs->csize / 2)
-       );
 
-       res = f_mount(NULL, argv[1], 0);
+       f_mount(NULL, argv[1], 0);
        if (res) {
                put_rc(res);
                return CMD_RET_FAILURE;
@@ -396,3 +405,120 @@ command_ret_t do_fat_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const ar
 
        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[])
+{
+       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 buserr = 0;
+       uint32_t timer;
+       uint8_t buffer[512];
+
+       (void) cmdtp; (void) flag;
+
+       if (argc < (dowrite ? 4 : 3))
+               return CMD_RET_USAGE;
+
+       addr = strtoul(argv[2], 0, 16);
+       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);
+       else
+               bytes = MAX_MEMORY;
+       if (argc > 4)
+               pos = strtoul(argv[4], 0, 16);
+       else
+               pos = 0;
+
+       if (addr + bytes > MAX_MEMORY)
+               bytes = MAX_MEMORY - addr;
+
+       res = f_mount(&FatFs, argv[1], 0);
+       if (!res) {
+               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 >= sizeof buffer)     {
+                                               cnt = sizeof buffer;
+                                               bytes -= sizeof buffer;
+                                       } 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 (ctrlc()) {
+                                               printf_P(PSTR("Abort\n"));
+                                               break;
+                                       }
+                               }
+
+                               FRESULT fr = f_close(&File);
+                               if (!res)
+                                       res = fr;
+                               timer = get_timer(timer);
+                               printf_P(PSTR("%lu (0x%lx) bytes read/written with %lu bytes/sec.\n"),
+                                                       bytes_rw, bytes_rw, timer ? (bytes_rw * 1000 / timer) : 0);
+                       }
+               }
+               f_mount(NULL, argv[1], 0);
+       }
+
+       if (buserr)
+               my_puts_P(PSTR("Bus timeout\n"));
+       if (res)
+               put_rc(res);
+       if (buserr || res)
+               return CMD_RET_FAILURE;
+
+       return CMD_RET_SUCCESS;
+}

diff --git a/avr/cmd_gpio.c b/avr/cmd_gpio.c
index 84723d2372453f2d14e9f0913284cc4b03bf6f58..f448e36e53cc61a54217affce491d9f8d8b9d139 100644 (file)
--- a/avr/cmd_gpio.c
+++ b/avr/cmd_gpio.c
@@ -29,6 +29,8 @@ static void pinnames_get(void)
        memset(pin_names, 0, sizeof(pin_names));
        pin_names_width = 0;
 
+/* TODO: enters endless loop on wron parameters */
+
        if ((lp = getenv(PSTR(ENV_PINALIAS))) != NULL) {
                pin_names[namestr] = strdup(lp);
                ptr = strtok_P(pin_names[namestr], delim1);

diff --git a/avr/command_tbl.c b/avr/command_tbl.c
index 02d8ac8eb82f85a4b2dbae5dbf6a4f63d167a4c1..e5c6567b667395064fb05514016893d813d6e07f 100644 (file)
--- a/avr/command_tbl.c
+++ b/avr/command_tbl.c
@@ -24,8 +24,10 @@ extern command_ret_t do_gpio(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_sd(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_fat_stat(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_fat_ls(cmd_tbl_t *, int, int, char * const []);
-extern command_ret_t do_fat_read(cmd_tbl_t *, int, int, char * const []);
-extern command_ret_t do_fat_write(cmd_tbl_t *, int, int, char * const []);
+//extern command_ret_t do_fat_read(cmd_tbl_t *, int, int, char * const []);
+//extern command_ret_t do_fat_write(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_fat_rw(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_testarg(cmd_tbl_t *, int, int, char * const []);
 
 #ifdef CONFIG_SYS_LONGHELP
 const FLASH char sd_help_text[] =
@@ -46,6 +48,22 @@ CMD_TBL_ITEM(
 ),
 
 #ifdef DEBUG
+CMD_TBL_ITEM(
+       test,   CONFIG_SYS_MAXARGS,     1,      do_testarg,
+       "print arguments",
+       ""
+),
+CMD_TBL_ITEM(
+       tst1,   CONFIG_SYS_MAXARGS,     1,      do_testarg,
+       "print arguments",
+       ""
+),
+CMD_TBL_ITEM(
+       tst2,   CONFIG_SYS_MAXARGS,     1,      do_testarg,
+       "print arguments",
+       ""
+),
+
 CMD_TBL_ITEM(
        !mdr,   3,      1,      do_dump_mem,
        "RAM dump",
@@ -254,7 +272,7 @@ CMD_TBL_ITEM(
        "path"
 ),
 CMD_TBL_ITEM(
-       fatload,        5,      0,      do_fat_read,
+       fatload,        5,      0,      do_fat_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"
@@ -265,11 +283,12 @@ CMD_TBL_ITEM(
        "      the load stops on end of file."
 ),
 CMD_TBL_ITEM(
-       fatwrite,       4,      0,      do_fat_write,
+       fatwrite,       4,      0,      do_fat_rw,
        "write file into a dos filesystem",
        "<d:/path/filename> <addr> <bytes>\n"
-       "    - write file 'filename' from the address 'addr' in RAM\n"
-       "      to 'dev' on 'interface'"
+       "    - Write file to 'path/filename' on logical drive 'd' from RAM\n"
+       "      starting at address 'addr'. 'bytes' gives the size to load.\n"
+       "      If 'bytes' is 0 or omitted, the load stops on end of file."
 ),
 
 CMD_TBL_ITEM(

diff --git a/avr/debug.c b/avr/debug.c
index 27b5329d5defdf39f9ffc8dc5e56d79f28fc3e25..796647b7d6f78d19a9bbbea3a830776faa57a82b 100644 (file)
--- a/avr/debug.c
+++ b/avr/debug.c
@@ -112,6 +112,17 @@ command_ret_t do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[
        return CMD_RET_SUCCESS;
 }
 
+
+/*------------------------------------------------------------------------------*/
+
+command_ret_t do_testarg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+       my_puts_P(cmdtp->name);
+       printf_P(PSTR("\n%s\n"), argv[0]);
+
+       return CMD_RET_SUCCESS;
+}
+
 /*------------------------------------------------------------------------------*/
 
 

diff --git a/include/avr/ffconf.h b/include/avr/ffconf.h
index cccab265de239623e2b4daff1a2318e602b5f16b..fadbe3d4d361720adf96d7889ff47fbf5ccb3f37 100644 (file)
--- a/include/avr/ffconf.h
+++ b/include/avr/ffconf.h
@@ -8,7 +8,7 @@
 / Functions and Buffer Configurations
 /---------------------------------------------------------------------------*/
 
-#define        _FS_TINY                0
+#define        _FS_TINY                1
 /* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
 /  At the tiny configuration, size of the file object (FIL) is reduced _MAX_SS
 /  bytes. Instead of private sector buffer eliminated from the file object,