cmd_fat.c, cmd_sd: use cmd_error()

diff --git a/avr/cmd_fat.c b/avr/cmd_fat.c
index 7cc9e46ee9ae942691c38f7edd1923fa051cd817..77505b4b01d0eca453a1948b20f29d8ee4629741 100644 (file)
--- a/avr/cmd_fat.c
+++ b/avr/cmd_fat.c
@@ -20,7 +20,7 @@
 #include "timer.h"
 #include "debug.h"
 #include "env.h"
-
+#include "errnum.h"
 
 #define DEBUG_FA               0       /* set to 1 to debug */
 
@@ -98,41 +98,6 @@ static const FLASH char * const FLASH rc_strings[] = {
                        FSTR("Invalid parameter")
                };
 
-static const FLASH char * const FLASH rc_names[] = {
-                       FSTR("OK"),
-                       FSTR("DISK_ERR"),
-                       FSTR("INT_ERR"),
-                       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
-void put_rc (FRESULT rc)
-{
-#if GCC_BUG_61443
-       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 < ARRAY_SIZE(rc_names) ? rc_names[rc] : PSTR(" Unknown Error"));
-#endif
-}
 
 
 const FLASH char * fat_rctostr(FRESULT rc)
@@ -204,7 +169,7 @@ static PATH_T *path_setup(char *string)
 
        PATH_T *p = (PATH_T *) malloc(sizeof *p);
        if (p == NULL) {
-               cmd_error(0, 0, PSTR("'%s': Out of Memory"), string);
+               cmd_error(0, ENOMEM, NULL);
                return NULL;
        }
 
@@ -216,7 +181,7 @@ static PATH_T *path_setup(char *string)
                        p->p_path[2] = '/';
                        len += 1;
                } else {
-                       cmd_error(0, 0, PSTR("'%s': Out of Memory"), string);
+                       cmd_error(0, ENOMEM, NULL);
                        return NULL;
                }
        }
@@ -241,10 +206,8 @@ command_ret_t do_pwd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc
        char *buf;
 
        buf = (char *) malloc(PATH_MAX);
-       if (buf == NULL) {
-               printf_P(PSTR("pwd: Out of Memory!\n"));
-               return CMD_RET_FAILURE;
-       }
+       if (buf == NULL)
+               cmd_error(CMD_RET_FAILURE, ENOMEM, NULL);
        *buf = '\0';
        res = f_getcwd(buf, PATH_MAX);  /* Get current directory path */
 
@@ -254,11 +217,9 @@ command_ret_t do_pwd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc
                puts(buf);
        }
        free(buf);
-       if (res != FR_OK) {
+       if (res != FR_OK)
                cmd_error(CMD_RET_FAILURE, res, NULL);
-               //put_rc(res);
-               //return CMD_RET_FAILURE;
-       }
+
        return CMD_RET_SUCCESS;
 }
 
@@ -275,8 +236,7 @@ command_ret_t do_cd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int 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;
+                       cmd_error(CMD_RET_FAILURE, 0, PSTR("\"%S\" is not set"), PSTR(ENV_HOME));
                }
        } else
                arg = argv[1];
@@ -294,10 +254,9 @@ command_ret_t do_cd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc,
                debug_fa("### f_chdir():   p_path: '%s', res: %d\n", path->p_path, res);
        }
        free(path);
-       if (res != FR_OK) {
-               put_rc(res);
-               return CMD_RET_FAILURE;
-       }
+       if (res != FR_OK)
+               cmd_error(CMD_RET_FAILURE, res, NULL);
+
        return CMD_RET_SUCCESS;
 }
 
@@ -318,10 +277,8 @@ command_ret_t do_ls(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc,
 
 
        buf = (char *) malloc(PATH_MAX);
-       if (buf == NULL) {
-               printf_P(PSTR("pwd: Out of Memory!\n"));
-               return CMD_RET_FAILURE;
-       }
+       if (buf == NULL)
+               cmd_error(CMD_RET_FAILURE, ENOMEM, NULL);
 
        if (argc < 2)
                res = f_getcwd(buf, PATH_MAX);  /* Get current directory path */
@@ -332,8 +289,7 @@ command_ret_t do_ls(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc,
                res = f_opendir(&Dir, buf);
        if (res != FR_OK) {
                free(buf);
-               put_rc(res);
-               return CMD_RET_FAILURE;
+               cmd_error(CMD_RET_FAILURE, res, NULL);
        }
 
        p1 = s1 = s2 = 0;
@@ -366,10 +322,8 @@ command_ret_t do_ls(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc,
        }
 
        free(buf);
-       if (res) {
-               put_rc(res);
-               return CMD_RET_FAILURE;
-       }
+       if (res)
+               cmd_error(CMD_RET_FAILURE, res, NULL);
 
        return CMD_RET_SUCCESS;
 }
@@ -468,10 +422,8 @@ command_ret_t do_stat(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int arg
        struct stat_dat_s statp;
 
        buf = (char *) malloc(PATH_MAX);
-       if (buf == NULL) {
-               printf_P(PSTR("fat stat: Out of Memory!\n"));
-               return CMD_RET_FAILURE;
-       }
+       if (buf == NULL)
+               cmd_error(CMD_RET_FAILURE, ENOMEM, NULL);
 
        if (argc > 1)
                path = argv[1];
@@ -519,10 +471,9 @@ command_ret_t do_stat(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int arg
        }
 
        free(buf);
-       if (res) {
-               put_rc(res);
-               return CMD_RET_FAILURE;
-       }
+       if (res)
+               cmd_error(CMD_RET_FAILURE, res, NULL);
+
        return CMD_RET_SUCCESS;
 }
 
@@ -549,10 +500,9 @@ command_ret_t do_rw(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc,
                return CMD_RET_USAGE;
 
        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 (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
@@ -566,80 +516,74 @@ command_ret_t do_rw(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc,
                bytes = MAX_MEMORY - addr;
 
        buffer = (uint8_t *) malloc(BUFFER_SIZE);
-       if (buffer == NULL) {
-               printf_P(PSTR("fatstat: Out of Memory!\n"));
-               return CMD_RET_FAILURE;
-       }
+       if (buffer == NULL)
+               cmd_error(CMD_RET_FAILURE, ENOMEM, NULL);
 
-       if (!res) {
-               res = f_open(&File, argv[1], dowrite ? FA_WRITE | FA_CREATE_ALWAYS
-                                                                                        : FA_READ );
+       res = f_open(&File, argv[1], dowrite ? FA_WRITE | FA_CREATE_ALWAYS
+                                                                                : FA_READ );
 
+       if (!res) {
+               res = f_lseek(&File, pos);
                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"));
+                       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;
                                        }
-                                       if (check_abort())
+                                       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;
 
-                               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);
+                               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 (buserr)
-               my_puts_P(PSTR("Bus timeout\n"));
        if (res)
-               put_rc(res);
+               cmd_error(CMD_RET_FAILURE, res, PSTR("'%s'"), argv[1]);
        if (buserr || res)
-               return CMD_RET_FAILURE;
+               cmd_error(CMD_RET_FAILURE, EBUSTO, NULL);
 
        return CMD_RET_SUCCESS;
 }

diff --git a/avr/cmd_sd.c b/avr/cmd_sd.c
index 1612a6fac97f6b5c13c4789a403a0da7aeaf3f2d..b1922159c5a1dc00eac6acad56e4b080551593aa 100644 (file)
--- a/avr/cmd_sd.c
+++ b/avr/cmd_sd.c
@@ -11,6 +11,7 @@
 #include "eval_arg.h"
 #include "print-utils.h"
 #include "z80-if.h"
+#include "errnum.h"
 
 
 /*
@@ -52,10 +53,8 @@ command_ret_t do_init(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * cons
 
        dev = (BYTE) eval_arg(argv[1], NULL);
 
-       if (disk_status(dev) & STA_NODISK) {
-               printf_P(PSTR("No Disk\n"));
-               return CMD_RET_FAILURE;
-       }
+       if (disk_status(dev) & STA_NODISK)
+               cmd_error(CMD_RET_FAILURE, 0, PSTR("No disk"));
 
        res = disk_initialize(dev);
        printf_P(PSTR("rc=%.2x\n"), res);
@@ -154,10 +153,8 @@ command_ret_t do_dump(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * cons
        for ( ; count; count--, sec++) {
                res = disk_read(dev, buffer, sec, 1);
 
-               if (res) {
-                       printf_P(PSTR("rc=%.2x\n"), res);
-                       return CMD_RET_FAILURE;
-               }
+               if (res)
+                       cmd_error(CMD_RET_FAILURE, 0, PSTR("rc=%.2x"), res);
 
                sprintf_P(header, PSTR("Sector: %lu"), sec);
                dump_ram(buffer, 0, FF_MAX_SS, header);
@@ -208,10 +205,9 @@ command_ret_t do_read(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * cons
        for (nr = 0; nr < count;) {
                nr++;
                if ((res = disk_read(dev, buffer, sec, 1)) == RES_OK) {
-                       if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
-                               my_puts_P(PSTR("Bus timeout\n"));
-                               return  CMD_RET_FAILURE;
-                       }
+                       if (!(z80_bus_cmd(Request) & ZST_ACQUIRED))
+                               cmd_error(CMD_RET_FAILURE, EBUSTO, NULL);
+
                        z80_write_block(buffer, addr /*+ base*/, FF_MAX_SS);
                        z80_bus_cmd(Release);
                        sec++; addr += FF_MAX_SS;
@@ -269,10 +265,9 @@ command_ret_t do_write(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * con
 
        for (nr = 0; nr < count;) {
                nr++;
-               if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
-                       my_puts_P(PSTR("Bus timeout\n"));
-                       return  CMD_RET_FAILURE;
-               }
+               if (!(z80_bus_cmd(Request) & ZST_ACQUIRED))
+                       cmd_error(CMD_RET_FAILURE, EBUSTO, NULL);
+
                z80_read_block(buffer, addr /*+ base*/, FF_MAX_SS);
                z80_bus_cmd(Release);
 

diff --git a/avr/strerror.c b/avr/strerror.c
index d80a3bce1982c0f91412a18d88d08539f099e880..bb151adb5ba63857e80d85aa0178aeeda4537ff0 100644 (file)
--- a/avr/strerror.c
+++ b/avr/strerror.c
@@ -5,20 +5,22 @@
  */
 
 #include "common.h"
+#include "errnum.h"
 #include "cmd_fat.h"
 
+
 static const FLASH char * const FLASH error_strings[] = {
-       FSTR("Unknown error")
+       FSTR("Unknown error"),
+       FSTR("Not enough memory"),
+       FSTR("Bus timeout")
 };
 
-const FLASH char * my_strerror_P(int errnum)
+const FLASH char * my_strerror_P(ERRNUM errnum)
 {
        if (errnum < 100)
                return fat_rctostr(errnum);
 
        errnum -= 100;
-       if (errnum < 0)
-               errnum = 0;
        if ((unsigned) errnum >= ARRAY_SIZE(error_strings))
                errnum = 0;
 

diff --git a/include/errnum.h b/include/errnum.h
new file mode 100644 (file)
index 0000000..5de8f2b
--- /dev/null
+++ b/include/errnum.h
@@ -0,0 +1,17 @@
+/*
+ * (C) Copyright 2018 Leo C. <erbl259-lmu@yahoo.de>
+ *
+ * SPDX-License-Identifier:    GPL-2.0
+ */
+
+#ifndef ERRNUM_H
+#define ERRNUM_H
+
+#include "errnum.h"
+
+typedef enum {
+       ENOMEM = 101,
+       EBUSTO
+} ERRNUM;
+
+#endif /* ERRNUM_H */

diff --git a/include/strerror.h b/include/strerror.h
index 9cc082195e3e0da84bdd7c2e139acd496153e771..045731622838b83ed4885c55392f84fc11d6cad1 100644 (file)
--- a/include/strerror.h
+++ b/include/strerror.h
@@ -1,5 +1,5 @@
 /*
- * (C) Copyright 2014 Leo C. <erbl259-lmu@yahoo.de>
+ * (C) Copyright 2018 Leo C. <erbl259-lmu@yahoo.de>
  *
  * SPDX-License-Identifier:    GPL-2.0
  */
@@ -7,6 +7,8 @@
 #ifndef STRERROR_H
 #define STRERROR_H
 
-const FLASH char * my_strerror_P(int errnum);
+#include "errnum.h"
+
+const FLASH char * my_strerror_P(ERRNUM errnum);
 
 #endif /* STRERROR_H */