X-Git-Url: http://cloudbase.mooo.com/gitweb/z180-stamp.git/blobdiff_plain/69988dc1f60ce27d2192eb2aa579962f585fffc8..0dd441e803f3563839541e7526f8294032aa7743:/avr/cmd_mem.c diff --git a/avr/cmd_mem.c b/avr/cmd_mem.c index 91668bd..763b857 100644 --- a/avr/cmd_mem.c +++ b/avr/cmd_mem.c @@ -1,8 +1,10 @@ /* + * (C) Copyright 2014 Leo C. + * * (C) Copyright 2000 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. * - * SPDX-License-Identifier: GPL-2.0+ + * SPDX-License-Identifier: GPL-2.0 */ /* @@ -12,19 +14,19 @@ */ #include "common.h" -#include #include +#include -#include "config.h" -#include "debug.h" #include "command.h" #include "cli_readline.h" +#include "print-utils.h" #include "con-utils.h" +#include "getopt-min.h" +#include "eval_arg.h" +#include "timer.h" #include "z80-if.h" +#include "debug.h" -/* - * TODO: printf() --> printf_P() - */ #ifndef CONFIG_SYS_MEMTEST_SCRATCH #define CONFIG_SYS_MEMTEST_SCRATCH 0 @@ -41,72 +43,16 @@ static uint32_t base_address = 0; /*--------------------------------------------------------------------------*/ -static void print_blanks(uint_fast8_t count) +int z180_read_buf(uint8_t *buf, uint32_t addr, uint8_t count) { - while(count--) - putchar(' '); -} - -int z180_dump_mem(uint32_t startaddr, uint32_t len, const char *title) -{ - uint8_t buf[16]; - uint8_t llen = 16; - uint8_t pre = startaddr % 16; - uint32_t addr = startaddr & ~0x0f; - len += pre; - uint8_t i; - - if (title && *title) - printf_P(PSTR("%s\n"),title); - - while (len) { - if (len < 16) - llen = len; - - z80_bus_cmd(Request); - for (i = pre; i < llen; i++) - buf[i] = z80_read(addr + i); - z80_bus_cmd(Release); - - printf_P(PSTR("%.5lx:"), addr); -#if 0 - print_blanks(3 * pre); - - /* Print hex values */ - for (i = pre; i < llen; i++) - printf_P(PSTR(" %.2x"), buf[i]); -#else - for (i = 0; i < llen; i++) { - if ((i % 8) == 0) - putchar(' '); - if (i < pre) - printf_P(PSTR(".. ")); - else - printf_P(PSTR("%.2x "), buf[i]); - } -#endif - /* fill line with whitespace for nice ASCII print */ -#if 1 - print_blanks(3 * (16u - i) + (16u-i)/8 + 1 + pre); -#else + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) + return -1; -#endif - /* Print data in ASCII characters */ - for (i = pre; i < llen; i++) - printf_P(PSTR("%c"), isprint(buf[i]) ? buf[i] : '.'); - putchar('\n'); - - pre = 0; - addr += 16; - len -= llen; - - if (ctrlc()) - return -1; - } + z80_read_block (buf, addr, count); + z80_bus_cmd(Release); return 0; } - /*--------------------------------------------------------------------------*/ /* Memory Display @@ -114,13 +60,13 @@ int z180_dump_mem(uint32_t startaddr, uint32_t len, const char *title) * Syntax: * md {addr} {len} */ -command_ret_t do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +command_ret_t do_mem_md(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { uint32_t addr, length; - + (void) cmdtp; -#if 0 +#if 0 printf_P(PSTR("flag: %d, argc: %d"), flag, argc); for (int i = 0; i < argc; i++) { printf_P(PSTR(", argv[%d]: %s"), i, argv[i] ? argv[i] : ""); @@ -139,19 +85,25 @@ command_ret_t do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[ if ((flag & CMD_FLAG_REPEAT) == 0) { /* Address is specified since argc > 1 */ - addr = strtoul(argv[1], NULL, 16); + addr = eval_arg(argv[1], NULL); addr += base_address; /* If another parameter, it is the length to display. */ if (argc > 2) - length = strtoul(argv[2], NULL, 16); + length = eval_arg(argv[2], NULL); } /* Print the lines. */ - z180_dump_mem(addr, length, NULL); + int ret = dump_mem(addr, addr, length, z180_read_buf, NULL); + if (ret == -2) { /* TODO: Error codes */ + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; + } - dp_last_addr = addr + length; - dp_last_length = length; + if (ret >= 0) { + dp_last_addr = addr + length; + dp_last_length = length; + } return CMD_RET_SUCCESS; } @@ -162,7 +114,7 @@ command_ret_t do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[ * nm {addr} */ static command_ret_t -mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[]) +mod_mem(cmd_tbl_t *cmdtp, int incrflag, uint_fast8_t flag, int argc, char * const argv[]) { uint32_t addr; uint8_t data; @@ -184,7 +136,7 @@ mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[]) /* Address is specified since argc > 1 */ - addr = strtoul(argv[1], NULL, 16); + addr = eval_arg(argv[1], NULL); addr += base_address; } @@ -192,12 +144,15 @@ mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[]) * the next value. A non-converted value exits. */ do { - z80_bus_cmd(Request); + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; + } data = z80_read(addr); - printf_P(PSTR("%05lx: %02x"), addr, data); z80_bus_cmd(Release); + printf_P(PSTR("%05lx: %02x"), addr, data); - nbytes = cli_readline(PSTR(" ? ")); + nbytes = cli_readline(PSTR(" ? "), 0); if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) { /* pressed as only input, don't modify current * location and move to next. "-" pressed will go back. @@ -205,66 +160,93 @@ mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[]) if (incrflag) addr += nbytes ? -1 : 1; nbytes = 1; - } - else { + + } else { char *endp; - data = strtoul(console_buffer, &endp, 16); + data = eval_arg(console_buffer, &endp); nbytes = endp - console_buffer; if (nbytes) { - z80_bus_cmd(Request); + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; + } z80_write(addr, data); z80_bus_cmd(Release); if (incrflag) addr++; } } - } while (nbytes); + } while (nbytes > 0); mm_last_addr = addr; return CMD_RET_SUCCESS; } -command_ret_t do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +command_ret_t do_mem_mm(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { return mod_mem (cmdtp, 1, flag, argc, argv); } -command_ret_t do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +command_ret_t do_mem_nm(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { return mod_mem (cmdtp, 0, flag, argc, argv); } -command_ret_t do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +command_ret_t do_mem_mw(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { - uint8_t writeval; - uint32_t addr, count; + uint32_t writeval; + uint32_t addr; + uint32_t count = 1; + uint_fast8_t width = 1; - (void) cmdtp; - (void) flag; + (void) cmdtp; (void) flag; + + /* reset getopt() */ + optind = 0; - if ((argc < 3) || (argc > 4)) + int opt; + while ((opt = getopt(argc, argv, PSTR("bwl"))) != -1) { + switch (opt) { + case 'b': + width = 1; + break; + case 'w': + width = 2; + break; + case 'l': + width = 4; + break; + default: /* '?' */ + return CMD_RET_USAGE; + } + } + + /* remaining arguments */ + argc -= optind; + if ((argc < 2) || (argc > 3)) return CMD_RET_USAGE; - /* Address is specified since argc > 1 - */ - addr = strtoul(argv[1], NULL, 16); + /* Address and value are specified since (adjusted) argc >= 2 */ + addr = eval_arg(argv[optind++], NULL); addr += base_address; - - /* Get the value to write. - */ - writeval = (uint8_t) strtoul(argv[2], NULL, 16); + writeval = eval_arg(argv[optind++], NULL); /* Count ? */ - if (argc == 4) { - count = strtoul(argv[3], NULL, 16); - } else { - count = 1; + if (argc == 3) + count = eval_arg(argv[optind], NULL); + + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; } - z80_bus_cmd(Request); - while (count-- > 0) { - z80_write(addr, writeval); - ++addr; + if (width == 1) + z80_memset(addr, writeval, count); + else { + while (count--) { + z80_write_block((const uint8_t *) &writeval, addr, width); + addr += width; + } } z80_bus_cmd(Release); @@ -272,64 +254,53 @@ command_ret_t do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[ } #ifdef CONFIG_MX_CYCLIC -command_ret_t do_mem_mdc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +command_ret_t do_mem_mdc ( cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { - int i; uint32_t count; + uint32_t ts; - if (argc < 4) - return CMD_RET_USAGE; - - count = strtoul(argv[3], NULL, 10); - - for (;;) { - do_mem_md (NULL, 0, 3, argv); - - /* delay for ms... */ -/* TODO: use timer */ - for (i=0; i ms... */ -/* TODO: use timer */ - for (i=0; i ms... */ + ts = get_timer(0); + do { + /* check for ctrl-c to abort... */ + if (had_ctrlc() || ctrlc()) { + my_puts_P(PSTR("Abort\n")); + return CMD_RET_SUCCESS; + } + } while (get_timer(ts) < count); } return CMD_RET_SUCCESS; } #endif /* CONFIG_MX_CYCLIC */ -command_ret_t do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +command_ret_t do_mem_cmp(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { uint32_t addr1, addr2, count, ngood; command_ret_t rcode = CMD_RET_SUCCESS; @@ -342,20 +313,24 @@ command_ret_t do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv return CMD_RET_USAGE; - addr1 = strtoul(argv[1], NULL, 16); + addr1 = eval_arg(argv[1], NULL); addr1 += base_address; - addr2 = strtoul(argv[2], NULL, 16); + addr2 = eval_arg(argv[2], NULL); addr2 += base_address; - count = strtoul(argv[3], NULL, 16); + count = eval_arg(argv[3], NULL); for (ngood = 0; ngood < count; ++ngood) { - z80_bus_cmd(Request); + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + rcode = CMD_RET_FAILURE; + break; + } byte1 = z80_read(addr1); byte2 = z80_read(addr2); z80_bus_cmd(Release); if (byte1 != byte2) { - printf( "byte at 0x%05lx (%#02x) != " - "byte at 0x%05lx (%#02x)\n", + printf_P(PSTR("byte at 0x%05lx (%#02x) != " + "byte at 0x%05lx (%#02x)\n"), addr1, byte1, addr2, byte2); rcode = CMD_RET_FAILURE; break; @@ -374,7 +349,7 @@ command_ret_t do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv return rcode; } -command_ret_t do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +command_ret_t do_mem_cp(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { uint32_t src, dest, count; int_fast8_t step; @@ -385,17 +360,17 @@ command_ret_t do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[ if (argc != 4) return CMD_RET_USAGE; - src = strtoul(argv[1], NULL, 16); + src = eval_arg(argv[1], NULL); src += base_address; - dest = strtoul(argv[2], NULL, 16); + dest = eval_arg(argv[2], NULL); dest += base_address; - count = strtoul(argv[3], NULL, 16); + count = eval_arg(argv[3], NULL); if (count == 0) { my_puts_P(PSTR("Zero length?\n")); return CMD_RET_FAILURE; } - + if (dest > src) { src += count - 1; dest += count - 1; @@ -405,7 +380,10 @@ command_ret_t do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[ while (count-- > 0) { uint8_t data; - z80_bus_cmd(Request); + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; + } data = z80_read(src); z80_write(dest, data); z80_bus_cmd(Release); @@ -421,7 +399,7 @@ command_ret_t do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[ return CMD_RET_SUCCESS; } -command_ret_t do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc, +command_ret_t do_mem_base(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { (void) cmdtp; @@ -429,14 +407,14 @@ command_ret_t do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc, if (argc > 1) { /* Set new base address. */ - base_address = strtoul(argv[1], NULL, 16); + base_address = eval_arg(argv[1], NULL); } /* Print the current base address. */ printf_P(PSTR("Base Address: 0x%05lx\n"), base_address); return CMD_RET_SUCCESS; } -command_ret_t do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc, +command_ret_t do_mem_loop(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { uint32_t addr, length; @@ -448,36 +426,41 @@ command_ret_t do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_USAGE; /* Address is always specified. */ - addr = strtoul(argv[1], NULL, 16); + addr = eval_arg(argv[1], NULL); /* Length is the number of bytes. */ - length = strtoul(argv[2], NULL, 16); + length = eval_arg(argv[2], NULL); /* We want to optimize the loops to run as fast as possible. * If we have only one object, just run infinite loops. */ if (length == 1) { - z80_bus_cmd(Request); + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; + } + cli(); for (;;) z80_read(addr); - z80_bus_cmd(Release); } - z80_bus_cmd(Request); + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; + } + cli(); for (;;) { uint32_t i = length; uint32_t p = addr; while (i-- > 0) z80_read(p++); } - z80_bus_cmd(Release); return CMD_RET_SUCCESS; } -#ifdef CONFIG_LOOPW -command_ret_t do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +command_ret_t do_mem_loopw (cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { uint32_t addr, length; uint8_t data; @@ -489,22 +472,32 @@ command_ret_t do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char * const a return CMD_RET_USAGE; /* Address is always specified. */ - addr = strtoul(argv[1], NULL, 16); + addr = eval_arg(argv[1], NULL); /* Length is the number of bytes. */ - length = strtoul(argv[2], NULL, 16); + length = eval_arg(argv[2], NULL); - data = strtoul(argv[3], NULL, 16); + data = eval_arg(argv[3], NULL); - /* We want to optimize the loops to run as fast as possible. + /* + * We want to optimize the loops to run as fast as possible. * If we have only one object, just run infinite loops. */ if (length == 1) { - z80_bus_cmd(Request); + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; + } + cli(); for (;;) z80_write(addr, data); } + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; + } + cli(); for (;;) { uint32_t i = length; uint32_t p = addr; @@ -512,35 +505,33 @@ command_ret_t do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char * const a z80_write(p++, data); } } -#endif /* CONFIG_LOOPW */ + +//#define CONFIG_SYS_ALT_MEMTEST #ifdef CONFIG_CMD_MEMTEST -static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_addr, - vu_long *dummy) +static uint32_t mem_test_alt(uint32_t start_addr, uint32_t end_addr) { - vu_long *addr; + uint32_t addr; + uint32_t dummy; uint32_t errs = 0; - uint32_t val, readback; - int j; - vu_long offset; - vu_long test_offset; - vu_long pattern; - vu_long temp; - vu_long anti_pattern; - vu_long num_words; - static const FLASH uint32_t bitpattern[] = { - 0x00000001, /* single bit */ - 0x00000003, /* two adjacent bits */ - 0x00000007, /* three adjacent bits */ - 0x0000000F, /* four adjacent bits */ - 0x00000005, /* two non-adjacent bits */ - 0x00000015, /* three non-adjacent bits */ - 0x00000055, /* four non-adjacent bits */ - 0xaaaaaaaa, /* alternating 1/0 */ + uint32_t offset; + uint32_t test_offset; + uint8_t pattern; + uint8_t anti_pattern; + uint8_t temp; + uint32_t num_bytes; + + static const FLASH uint8_t bitpattern[] = { + 0x01, /* single bit */ + 0x03, /* two adjacent bits */ + 0x07, /* three adjacent bits */ + 0x0F, /* four adjacent bits */ + 0x05, /* two non-adjacent bits */ + 0x15, /* three non-adjacent bits */ + 0x55, /* four non-adjacent bits */ + 0xaa, /* alternating 1/0 */ }; - num_words = (end_addr - start_addr) / sizeof(vu_long); - /* * Data line test: write a pattern to the first * location, write the 1's complement to a 'parking' @@ -558,35 +549,39 @@ static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_add * '0's and '0' bits through a field of '1's (i.e. * pattern and ~pattern). */ - addr = buf; - for (j = 0; j < sizeof(bitpattern) / sizeof(bitpattern[0]); j++) { - val = bitpattern[j]; - for (; val != 0; val <<= 1) { - *addr = val; - *dummy = ~val; /* clear the test data off the bus */ - readback = *addr; - if (readback != val) { + addr = start_addr; + dummy = start_addr+1; + for (unsigned int j = 0; j < ARRAY_SIZE(bitpattern); j++) { + pattern = bitpattern[j]; + for (; pattern != 0; pattern <<= 1) { + anti_pattern = ~pattern; + z80_write(addr, pattern); + z80_write(dummy, anti_pattern); /* clear the test data off the bus */ + temp = z80_read(addr); + if (temp != pattern) { printf_P(PSTR("FAILURE (data line): " - "expected %05lx, actual %05lx\n"), - val, readback); + "expected %02x, actual %02x\n"), + pattern, temp); errs++; - if (ctrlc()) - return -1; } - *addr = ~val; - *dummy = val; - readback = *addr; - if (readback != ~val) { + z80_write(addr, anti_pattern); + z80_write(dummy, pattern); /* clear the test data off the bus */ + temp = z80_read(addr); + if (temp != anti_pattern) { printf_P(PSTR("FAILURE (data line): " - "Is %05lx, should be %05lx\n"), - readback, ~val); + "Is %02x, should be %02x\n"), + temp, anti_pattern); errs++; - if (ctrlc()) - return -1; } } + + if (ctrlc()) + return -1; } + if (errs) + return errs; + /* * Based on code whose Original Author and Copyright * information follows: Copyright (c) 1998 by Michael @@ -621,59 +616,61 @@ static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_add * * Returns: 0 if the test succeeds, 1 if the test fails. */ - pattern = (vu_long) 0xaaaaaaaa; - anti_pattern = (vu_long) 0x55555555; - debug("%s:%d: length = 0x%.5lx\n", __func__, __LINE__, num_words); + num_bytes = (end_addr - start_addr) / sizeof(uint8_t); + + pattern = 0xaa; + anti_pattern = 0x55; + +// debug("## %s:%d: length = 0x%.5lx\n", __func__, __LINE__, num_bytes); /* * Write the default pattern at each of the * power-of-two offsets. */ - for (offset = 1; offset < num_words; offset <<= 1) - addr[offset] = pattern; + for (offset = 1; offset < num_bytes; offset <<= 1) + z80_write(addr+offset, pattern); /* * Check for address bits stuck high. */ - test_offset = 0; - addr[test_offset] = anti_pattern; + z80_write(start_addr, anti_pattern); - for (offset = 1; offset < num_words; offset <<= 1) { - temp = addr[offset]; + for (offset = 1; offset < num_bytes; offset <<= 1) { + temp = z80_read(start_addr + offset); if (temp != pattern) { - 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); + printf_P(PSTR("FAILURE: Address bit stuck high @ 0x%.5lx:" + " expected 0x%.2x, actual 0x%.2x\n"), + start_addr + offset, pattern, temp); errs++; if (ctrlc()) return -1; } } - addr[test_offset] = pattern; + z80_write(start_addr, pattern); /* * Check for addr bits stuck low or shorted. */ - for (test_offset = 1; test_offset < num_words; test_offset <<= 1) { - addr[test_offset] = anti_pattern; + for (test_offset = 1; test_offset < num_bytes; test_offset <<= 1) { + z80_write(start_addr + test_offset, anti_pattern); - for (offset = 1; offset < num_words; offset <<= 1) { - temp = addr[offset]; + for (offset = 1; offset < num_bytes; offset <<= 1) { + temp = z80_read(start_addr + offset); if ((temp != pattern) && (offset != test_offset)) { - printf_P(PSTR("\nFAILURE: Address bit stuck low or" - " shorted @ 0x%.5lx: expected 0x%.5lx," - " actual 0x%.5lx\n"), - start_addr + offset*sizeof(vu_long), - pattern, temp); + printf_P(PSTR("FAILURE: Address bit stuck low or shorted" + " @ 0x%.5lx: expected 0x%.2x, actual 0x%.2x\n"), + start_addr + offset, pattern, temp); errs++; if (ctrlc()) return -1; } } - addr[test_offset] = pattern; + z80_write(start_addr + test_offset, pattern); } + if (errs) + return errs; + /* * Description: Test the integrity of a physical * memory device by performing an @@ -686,111 +683,50 @@ static uint32_t mem_test_alt(vu_long *buf, uint32_t start_addr, uint32_t end_add * * Returns: 0 if the test succeeds, 1 if the test fails. */ - num_words++; + num_bytes++; /* * Fill memory with a known pattern. */ - for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { - addr[offset] = pattern; - } + for (pattern = 1, addr = start_addr; addr <= end_addr; pattern++, addr++) + z80_write(addr, pattern); /* * Check each location and invert it for the second pass. */ - for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { - temp = addr[offset]; + for (pattern = 1, addr = start_addr; addr <= end_addr; pattern++, addr++) { + temp = z80_read(addr); if (temp != pattern) { - printf_P(PSTR("\nFAILURE (read/write) @ 0x%.5lx:" - " expected 0x%.5lx, actual 0x%.5lx)\n"), - start_addr + offset*sizeof(vu_long), - pattern, temp); + printf_P(PSTR("FAILURE (read/write) @ 0x%.5lx:" + " expected 0x%.2x, actual 0x%.2x)\n"), + addr, pattern, temp); errs++; if (ctrlc()) return -1; } anti_pattern = ~pattern; - addr[offset] = anti_pattern; + z80_write(addr, anti_pattern); } /* * Check each location for the inverted pattern and zero it. */ - for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { - WATCHDOG_RESET(); + for (pattern = 1, addr = start_addr; addr <= end_addr; pattern++, addr++) { anti_pattern = ~pattern; - temp = addr[offset]; + temp = z80_read(addr); if (temp != anti_pattern) { - 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++; - if (ctrlc()) - return -1; - } - addr[offset] = 0; - } - - return 0; -} - -static uint32_t mem_test_quick(vu_long *buf, uint32_t start_addr, uint32_t end_addr, - vu_long pattern, int iteration) -{ - vu_long *end; - vu_long *addr; - uint32_t errs = 0; - uint32_t incr, length; - uint32_t val, readback; - - /* Alternate the pattern */ - incr = 1; - if (iteration & 1) { - incr = -incr; - /* - * Flip the pattern each time to make lots of zeros and - * then, the next time, lots of ones. We decrement - * the "negative" patterns and increment the "positive" - * patterns to preserve this feature. - */ - if (pattern & 0x80000000) - pattern = -pattern; /* complement & increment */ - else - pattern = ~pattern; - } - length = (end_addr - start_addr) / sizeof(uint32_t); - end = buf + length; - printf_P(PSTR("\rPattern %08lX Writing..." - "%12s" - "\b\b\b\b\b\b\b\b\b\b"), - pattern, ""); - - for (addr = buf, val = pattern; addr < end; addr++) { - *addr = val; - val += incr; - } - - my_puts_P(PSTR("Reading...")); - - for (addr = buf, val = pattern; addr < end; addr++) { - readback = *addr; - if (readback != val) { - uint32_t offset = addr - buf; - - printf_P(PSTR("\nMem error @ 0x%08X: " - "found %08lX, expected %08lX\n"), - (unsigned int)(uintptr_t)(start_addr + offset*sizeof(vu_long)), - readback, val); + printf_P(PSTR("FAILURE (read/write) @ 0x%.5lx:" + " expected 0x%.2x, actual 0x%.2x)\n"), + start_addr, anti_pattern, temp); errs++; if (ctrlc()) return -1; } - val += incr; + z80_write(addr, 0); } - return 0; + return errs; } /* @@ -798,81 +734,64 @@ static uint32_t mem_test_quick(vu_long *buf, uint32_t start_addr, uint32_t end_a * configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until * interrupted by ctrl-c or by a failure of one of the sub-tests. */ -command_ret_t do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc, +command_ret_t do_mem_mtest(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[]) { - uint32_t start, end; - vu_long *buf, *dummy; - int iteration_limit; -/* TODO: command_ret_t */ + uint32_t start = 0; + uint32_t end; + unsigned int iteration_limit = 0; + unsigned int iteration; + uint32_t errs = 0; /* number of errors */ int ret; - uint32_t errs = 0; /* number of errors, or -1 if interrupted */ - uint32_t pattern; - int iteration; -#if defined(CONFIG_SYS_ALT_MEMTEST) - const int alt_test = 1; -#else - const int alt_test = 0; -#endif + + (void) cmdtp; + (void) flag; if (argc > 1) - start = strtoul(argv[1], NULL, 16); - else - start = CONFIG_SYS_MEMTEST_START; + start = eval_arg(argv[1], NULL); if (argc > 2) - end = strtoul(argv[2], NULL, 16); + end = eval_arg(argv[2], NULL); else - end = CONFIG_SYS_MEMTEST_END; + end = CONFIG_SYS_RAMSIZE_MAX - 1; if (argc > 3) - pattern = (uint32_t)strtoul(argv[3], NULL, 16); - else - pattern = 0; + iteration_limit = (unsigned int) eval_arg(argv[3], NULL); - if (argc > 4) - iteration_limit = (uint32_t)strtoul(argv[4], NULL, 16); - else - iteration_limit = 0; + printf_P(PSTR("Testing %05lx ... %05lx:\n"), start, end); +// debug("## %s:%d: start %#05lx end %#05lx\n", __func__, __LINE__, start, 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); + clear_ctrlc(); /* forget any previous Control C */ -/* TODO: */ -// buf = map_sysmem(start, end - start); -// dummy = map_sysmem(CONFIG_SYS_MEMTEST_SCRATCH, sizeof(vu_long)); for (iteration = 0; !iteration_limit || iteration < iteration_limit; iteration++) { - if (ctrlc()) { - errs = -1UL; - break; - } printf_P(PSTR("Iteration: %6d\r"), iteration + 1); - debug("\n"); - if (alt_test) { - errs = mem_test_alt(buf, start, end, dummy); - } else { - errs = mem_test_quick(buf, start, end, pattern, - iteration); +// debug("\n"); + + if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) { + my_puts_P(PSTR("Bus timeout\n")); + return CMD_RET_FAILURE; } - if (errs == -1UL) + errs += mem_test_alt(start, end); + z80_bus_cmd(Release); + + if (had_ctrlc() || ctrlc()) { break; + } } - if (errs == -1UL) { + if (had_ctrlc()) { /* Memory test was aborted - write a newline to finish off */ - putc('\n'); - ret = 1; + putchar('\n'); + ret = CMD_RET_FAILURE; } else { printf_P(PSTR("Tested %d iteration(s) with %lu errors.\n"), iteration, errs); - ret = errs != 0; + ret = errs ? CMD_RET_FAILURE : CMD_RET_SUCCESS; } - return ret; /* not reached */ + return ret; } #endif /* CONFIG_CMD_MEMTEST */ -