printf() --> printf_P(PSTR())

diff --git a/avr/cli.c b/avr/cli.c
index 01ad81b9048ae138e5274addeff6fcf1d173037d..f0dd15410af2415701bd4ac933fe765c4345e834 100644 (file)
--- a/avr/cli.c
+++ b/avr/cli.c
@@ -181,11 +181,11 @@ static int cli_run_command(const char *cmd, int flag)
        if (!cmd || !*cmd)
                return -1;      /* empty command */
 
-
-       cmdbuf = xmalloc(strlen(cmd) + 1);
        finaltoken = xmalloc(CONFIG_SYS_CBSIZE);
+       cmdbuf = strdup(cmd);
+       if (!cmdbuf)
+               return -1;      /* not enough memory */
 
-       strcpy(cmdbuf, cmd);
        str = cmdbuf;
 
        /* Process separators and check for invalid
@@ -309,11 +309,8 @@ void cli_loop(void)
 
                flag = 0;       /* assume no special flags for now */
                if (len > 0) {
-                       lastcommand = (char *) xrealloc(lastcommand, len+1);
-                       if (lastcommand != NULL) {
-                               strncpy(lastcommand, console_buffer, len+1);
-                               lastcommand[len] = '\0';
-                       }
+                       free (lastcommand);
+                       lastcommand = strdup(console_buffer);
                } else if (len == 0)
                        flag |= CMD_FLAG_REPEAT;
 

diff --git a/avr/cmd_mem.c b/avr/cmd_mem.c
index 6341e0b77682c5057fb27c964436654c176b3e24..91668bdf819a2e7bc0c9b4dc9eb9b84833a4242a 100644 (file)
--- a/avr/cmd_mem.c
+++ b/avr/cmd_mem.c
@@ -194,7 +194,7 @@ mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
        do {
                z80_bus_cmd(Request);
                data = z80_read(addr);
-               printf("%05lx: %02x", addr, data);
+               printf_P(PSTR("%05lx: %02x"), addr, data);
                z80_bus_cmd(Release);
 
                nbytes = cli_readline(PSTR(" ? "));
@@ -292,7 +292,7 @@ command_ret_t do_mem_mdc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const ar
 
                /* check for ctrl-c to abort... */
                if (ctrlc()) {
-                       my_puts("Abort\n");
+                       my_puts_P(PSTR("Abort\n"));
                        return CMD_RET_SUCCESS;
                }
        }
@@ -320,7 +320,7 @@ command_ret_t do_mem_mwc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const ar
 
                /* check for ctrl-c to abort... */
                if (ctrlc()) {
-                       my_puts("Abort\n");
+                       my_puts_P(PSTR("Abort\n"));
                        return CMD_RET_SUCCESS;
                }
        }
@@ -365,12 +365,12 @@ command_ret_t do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv
 
                /* check for ctrl-c to abort... */
                if (ctrlc()) {
-                       my_puts("Abort\n");
+                       my_puts_P(PSTR("Abort\n"));
                        return CMD_RET_SUCCESS;
                }
        }
 
-       printf("Total of %ld byte(s) (0x%lx) were the same\n", ngood, ngood);
+       printf_P(PSTR("Total of %ld byte(s) (0x%lx) were the same\n"), ngood, ngood);
        return rcode;
 }
 
@@ -392,7 +392,7 @@ command_ret_t do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[
        count = strtoul(argv[3], NULL, 16);
 
        if (count == 0) {
-               my_puts ("Zero length ???\n");
+               my_puts_P(PSTR("Zero length?\n"));
                return CMD_RET_FAILURE;
        }
        
@@ -414,7 +414,7 @@ command_ret_t do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[
 
                /* check for ctrl-c to abort... */
                if (ctrlc()) {
-                       my_puts("Abort\n");
+                       my_puts_P(PSTR("Abort\n"));
                        return CMD_RET_SUCCESS;
                }
        }
@@ -432,7 +432,7 @@ command_ret_t do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
                base_address = strtoul(argv[1], NULL, 16);
        }
        /* Print the current base address. */
-       printf("Base Address: 0x%05lx\n", base_address);
+       printf_P(PSTR("Base Address: 0x%05lx\n"), base_address);
        return CMD_RET_SUCCESS;
 }
 
@@ -566,8 +566,8 @@ static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_add
                        *dummy  = ~val; /* clear the test data off the bus */
                        readback = *addr;
                        if (readback != val) {
-                               printf("FAILURE (data line): "
-                                       "expected %05lx, actual %05lx\n",
+                               printf_P(PSTR("FAILURE (data line): "
+                                       "expected %05lx, actual %05lx\n"),
                                                val, readback);
                                errs++;
                                if (ctrlc())
@@ -577,8 +577,8 @@ static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_add
                        *dummy  = val;
                        readback = *addr;
                        if (readback != ~val) {
-                               printf("FAILURE (data line): "
-                                       "Is %05lx, should be %05lx\n",
+                               printf_P(PSTR("FAILURE (data line): "
+                                       "Is %05lx, should be %05lx\n"),
                                                readback, ~val);
                                errs++;
                                if (ctrlc())
@@ -641,8 +641,8 @@ static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_add
        for (offset = 1; offset < num_words; offset <<= 1) {
                temp = addr[offset];
                if (temp != pattern) {
-                       printf("\nFAILURE: Address bit stuck high @ 0x%.5lx:"
-                               " expected 0x%.5lx, actual 0x%.5lx\n",
+                       printf_P(PSTR("\nFAILURE: Address bit stuck high @ 0x%.5lx:"
+                               " expected 0x%.5lx, actual 0x%.5lx\n"),
                                start_addr + offset*sizeof(vu_long),
                                pattern, temp);
                        errs++;
@@ -661,9 +661,9 @@ static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_add
                for (offset = 1; offset < num_words; offset <<= 1) {
                        temp = addr[offset];
                        if ((temp != pattern) && (offset != test_offset)) {
-                               printf("\nFAILURE: Address bit stuck low or"
+                               printf_P(PSTR("\nFAILURE: Address bit stuck low or"
                                        " shorted @ 0x%.5lx: expected 0x%.5lx,"
-                                       " actual 0x%.5lx\n",
+                                       " actual 0x%.5lx\n"),
                                        start_addr + offset*sizeof(vu_long),
                                        pattern, temp);
                                errs++;
@@ -701,8 +701,8 @@ static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_add
        for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
                temp = addr[offset];
                if (temp != pattern) {
-                       printf("\nFAILURE (read/write) @ 0x%.5lx:"
-                               " expected 0x%.5lx, actual 0x%.5lx)\n",
+                       printf_P(PSTR("\nFAILURE (read/write) @ 0x%.5lx:"
+                               " expected 0x%.5lx, actual 0x%.5lx)\n"),
                                start_addr + offset*sizeof(vu_long),
                                pattern, temp);
                        errs++;
@@ -722,8 +722,8 @@ static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_add
                anti_pattern = ~pattern;
                temp = addr[offset];
                if (temp != anti_pattern) {
-                       printf("\nFAILURE (read/write): @ 0x%.5lx:"
-                               " expected 0x%.5lx, actual 0x%.5lx)\n",
+                       printf_P(PSTR("\nFAILURE (read/write): @ 0x%.5lx:"
+                               " expected 0x%.5lx, actual 0x%.5lx)\n"),
                                start_addr + offset*sizeof(vu_long),
                                anti_pattern, temp);
                        errs++;
@@ -762,9 +762,9 @@ static uint32_t mem_test_quick(vu_long *buf, uint32_t start_addr, uint32_t end_a
        }
        length = (end_addr - start_addr) / sizeof(uint32_t);
        end = buf + length;
-       printf("\rPattern %08lX  Writing..."
+       printf_P(PSTR("\rPattern %08lX  Writing..."
                "%12s"
-               "\b\b\b\b\b\b\b\b\b\b",
+               "\b\b\b\b\b\b\b\b\b\b"),
                pattern, "");
 
        for (addr = buf, val = pattern; addr < end; addr++) {
@@ -772,15 +772,15 @@ static uint32_t mem_test_quick(vu_long *buf, uint32_t start_addr, uint32_t end_a
                val += incr;
        }
 
-       my_puts("Reading...");
+       my_puts_P(PSTR("Reading..."));
 
        for (addr = buf, val = pattern; addr < end; addr++) {
                readback = *addr;
                if (readback != val) {
                        uint32_t offset = addr - buf;
 
-                       printf("\nMem error @ 0x%08X: "
-                               "found %08lX, expected %08lX\n",
+                       printf_P(PSTR("\nMem error @ 0x%08X: "
+                               "found %08lX, expected %08lX\n"),
                                (unsigned int)(uintptr_t)(start_addr + offset*sizeof(vu_long)),
                                readback, val);
                        errs++;
@@ -835,7 +835,7 @@ command_ret_t do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
        else
                iteration_limit = 0;
 
-       printf("Testing %08x ... %08x:\n", (unsigned int)start, (unsigned int)end);
+       printf_P(PSTR("Testing %08x ... %08x:\n"), (unsigned int)start, (unsigned int)end);
        debug("%s:%d: start %#05lx end %#05lx\n", __func__, __LINE__,
              start, end);
 
@@ -850,7 +850,7 @@ command_ret_t do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
                        break;
                }
 
-               printf("Iteration: %6d\r", iteration + 1);
+               printf_P(PSTR("Iteration: %6d\r"), iteration + 1);
                debug("\n");
                if (alt_test) {
                        errs = mem_test_alt(buf, start, end, dummy);
@@ -867,7 +867,7 @@ command_ret_t do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
                putc('\n');
                ret = 1;
        } else {
-               printf("Tested %d iteration(s) with %lu errors.\n",
+               printf_P(PSTR("Tested %d iteration(s) with %lu errors.\n"),
                        iteration, errs);
                ret = errs != 0;
        }

diff --git a/avr/debug.c b/avr/debug.c
index 45913973667affd3b4fa8c67d78b159361ede752..74d8ab2ad35fcc1cd9388cdae411355f6c7a742f 100644 (file)
--- a/avr/debug.c
+++ b/avr/debug.c
@@ -202,7 +202,7 @@ command_ret_t do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[
                return CMD_RET_FAILURE;
        }
        if (count == 0) {
-               debug("Zero length ???\n");
+               debug("Zero length?\n");
                return CMD_RET_FAILURE;
        }
 
@@ -223,5 +223,48 @@ command_ret_t do_eep_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[
        }
        return CMD_RET_SUCCESS;
 }
+
+/*------------------------------------------------------------------------------*/
+
+
+struct __freelist {
+       size_t sz;
+       struct __freelist *nx;
+};
+
+extern char *__brkval;         /* first location not yet allocated */
+extern struct __freelist *__flp; /* freelist pointer (head of freelist) */
+
+#define STACK_POINTER() ((char *)AVR_STACK_POINTER_REG)
+
+void
+printfreelist(const char * title)
+{
+       struct __freelist *fp1;
+       int i;
+       unsigned int freesum = 0;
+
+       if (!__flp) {
+               printf("%s no free list\n", title ? title : "");
+       } else {
+               printf("Free list: %s\n", title ? title : "");
+               for (i = 0, fp1 = __flp; fp1; i++, fp1 = fp1->nx) {
+                       printf("    entry %d @ %04x: size %4u, next ",
+                              i, (size_t)fp1, fp1->sz);
+                       if (fp1->nx)
+                               printf("%04x\n", (size_t)fp1->nx);
+                       else
+                               printf("NULL\n");
+                       freesum += fp1->sz;
+               }
+       }
+       
+       freesum +=  (size_t) STACK_POINTER() - __malloc_margin - (size_t) __brkval;
+
+       printf("SP: %04x, __brkval: %04x, Total free: %04u\n",
+               (size_t) STACK_POINTER(), (size_t) __brkval, freesum);
+}
+
+
 #endif /* DEBUG */
 

diff --git a/avr/debug.h b/avr/debug.h
index 1815166195761d684eab5b1917308c1d10f2649d..7c19e40fd186fb240e07ea91a70fe4d92ec50950 100644 (file)
--- a/avr/debug.h
+++ b/avr/debug.h
@@ -30,5 +30,9 @@
 #endif
 #endif /* 0 */
 
+
+void printfreelist(const char * title);
+
+
 #endif /* DEBUG_H_ */
 

diff --git a/avr/env.c b/avr/env.c
index 8487c6f5e0cffb096b8c9ecf537941eddc8ebf16..28437a433ccba7286eac672f9c2e8737b0e20085 100644 (file)
--- a/avr/env.c
+++ b/avr/env.c
@@ -102,6 +102,19 @@ uint16_t varname_get(char *buf, env_item_t *ep)
 }
 
 
+static
+uint16_t varval_getlen(uint16_t index)
+{
+       int i = 0;
+       char c;
+
+       while ((c = env_get_char (index + i)) != '\0') {
+               i++;
+       };
+
+       return i;
+}
+
 static
 uint16_t varval_get(char *buf, uint16_t index, int len)
 {
@@ -403,13 +416,17 @@ env_item_t *envlist_get(const char *name, uint_fast8_t flag)
        if (ep != NULL && (flag & ENV_GET_VAL)) {
                if (ep->flags & EF_V_EEP) {
                        char *vp;
-                       uint_fast8_t len;
-                       /* TODO: function that gets len of val, 
-                          to get rid of xrealloc */ 
-                       vp = xmalloc(CONFIG_SYS_CBSIZE);
-                       len = varval_get(vp, ep->val.eep, CONFIG_SYS_CBSIZE);
-                       ep->val.ram = xrealloc(vp, len + 1);
-                       ep->flags &= ~EF_V_EEP;
+                       int len;
+                       len = varval_getlen(ep->val.eep);
+                       if (len > CONFIG_SYS_CBSIZE)
+                               len = CONFIG_SYS_CBSIZE;
+                       vp = xmalloc(len + 1);
+                       if (vp) {
+                               varval_get(vp, ep->val.eep, len + 1);
+                               ep->val.ram = vp;
+                               ep->flags &= ~EF_V_EEP;
+                       } else
+                               printf_P(PSTR("Out of memory!\n"));
                }
        }                       
        

diff --git a/avr/main.c b/avr/main.c
index 5c4cd0c0bca48ebdd29bf0242c67e715df061f5e..c6a0f00929f2d97e7370ba11dbeba4b2f7dfae66 100644 (file)
--- a/avr/main.c
+++ b/avr/main.c
@@ -27,6 +27,18 @@
 #include "cli.h"
 #include "env.h"
 
+/*--------------------------------------------------------------------------*/
+#if DEBUG
+void preset_ram (void) __attribute__ ((naked)) \
+               __attribute__ ((section (".init3")));
+void
+preset_ram (void)
+{
+       for (uint8_t *p = RAMSTART; p <= (uint8_t *) RAMEND; p++)
+               *p = 0xdd;
+
+}
+#endif
 /*--------------------------------------------------------------------------*/
 
 static uint8_t mcusr;
@@ -92,7 +104,6 @@ void print_reset_reason(void)
 }
 
 
-/*******************************************************************************/
 /*******************************************************************************/
 
 #define udelay(n)  _delay_us(n)
@@ -193,14 +204,15 @@ void main_loop(void)
 
 int main(void)
 {
+
        setup_avr();
        z80_setup_bus();
        
        serial_setup();
        sei();
 
-       debug("\n=========================<  (RE)START DEBUG  >=========================\n");
 #if DEBUG
+       debug("\n=========================<  (RE)START DEBUG  >=========================\n");
        print_reset_reason();
 #endif