working connect command, new sleep command

diff --git a/avr/cmd_boot.c b/avr/cmd_boot.c
index 1f99f2d65c7e8dcbef0bb76ff7d65c802e88c980..2c3a533c04c91bea9630fbb8b29403fecd765b25 100644 (file)
--- a/avr/cmd_boot.c
+++ b/avr/cmd_boot.c
@@ -4,13 +4,14 @@
  */
 #include "common.h"
 #include <stdlib.h>
+#include <ctype.h>
 #include <util/atomic.h>
 
 #include "command.h"
 #include "con-utils.h"
 #include "z80-if.h"
 #include "z180-serv.h"
-//#include "debug.h"
+#include "debug.h"
 
 /* ugly hack to get Z180 loadfile into flash memory */
 #define const const FLASH
@@ -126,14 +127,21 @@ command_ret_t do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        return CMD_RET_SUCCESS;
 }
 
+static
+void reset_cpu(bus_cmd_t mode)
+{
+       restart_z180_serv();
+       z80_bus_cmd(mode);
+}
+
+
 command_ret_t do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
        (void) cmdtp; (void) flag; (void) argc; (void) argv;
 
        printf_P(PSTR("## CPU now in reset state.\n"));
 
-       restart_z180_serv();
-       z80_bus_cmd(Reset);
+       reset_cpu(Reset);
        return CMD_RET_SUCCESS;
 }
 
@@ -141,24 +149,40 @@ command_ret_t do_restart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv
 {
        (void) cmdtp; (void) flag; (void) argc; (void) argv;
 
-       restart_z180_serv();
-       z80_bus_cmd(Restart);
+       reset_cpu(Restart);
 
        return CMD_RET_SUCCESS;
 }
 
+static
+void print_con_usage(char esc)
+{      printf_P(PSTR("\n"
+               "------------------------------------------------\n"
+               " ?,H - This Help\n"
+               " R   - Reset (Restart) CPU\n"
+               " Q,X - Return to command line\n"
+               " \\  - code input:\n"
+               "      \\nnn   3 decimal digits character code\n"
+               "      \\Xhh   2 hexadecimal digits character code\n"
+               " ^%c - (Escape char) Type again to send itself\n"
+               "key>"
+       ), esc + 0x40);
+}
 
 command_ret_t do_console(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
        int ch;
-       uint8_t pending, state = 0;
+       uint8_t pending;
+//     uint8_t help_prompt = 0;
+       uint8_t code = 0;
+       uint8_t state = 0;
        
        (void) cmdtp; (void) flag; (void) argc; (void) argv;
 
 
        while (1) {
 
-               ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+               ATOMIC_BLOCK(ATOMIC_FORCEON) {
                        pending = (Stat & S_CON_PENDING) != 0;
                        Stat &= ~S_CON_PENDING;
                }
@@ -174,46 +198,78 @@ command_ret_t do_console(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv
                                        /* TODO: Timer starten */
                                } else {
                                        z80_memfifo_putc(fifo_conin, ch);
-//                                     serial_putc(ch);
-//                                     if (ch == '\r')
-//                                             serial_putc('\n');
                                }       
                                break;
+                       case 2:
+                               printf_P(PSTR("\n"
+                                 "------------------------------------------------\n"));
                        case 1:
-                               switch (ch) {
-
-                               case 'r':
-//                                     z80_reset_pulse();
-                                       break;
+                               state = 0;
+                               switch (toupper(ch)) {
 
-                               case 'b':
+                               case '?':
+                               case 'H':
+                                       print_con_usage(CONFIG_ESC_CHAR);
+                                       state = 2;
                                        break;
 
-                               case 'e':
+                               case 'R':
+                                       reset_cpu(Restart);
                                        break;
 
-                               case 'q':
+                               case 'X':
                                case 'Q':
                                        printf_P(PSTR("\n"));
                                        goto quit;
                                        break;
 
+                               case '\\':
+                                       code = 0;
+                                       state = 3;
+                                       break;
+
                                case CONFIG_ESC_CHAR:
-                               default:
                                        z80_memfifo_putc(fifo_conin, ch);
-//                                     serial_putc(ch);
-//                                     if (ch == '\r')
-//                                             serial_putc('\n');
+                                       break;
+                               default:
+                                       break;
+                               }
+                               break;
+                       case 3:
+                               if (toupper(ch) == 'X') {
+                                       state = 6;
+                                       break;
+                               }
+                               /* fall thru */
+                       case 4:
+                       case 5:
+                               if (isdigit(ch)) {
+                                       code = code * 10 + ch - '0';
+                                       state++;
+                               }
+                               if (state > 5) {
+                                       z80_memfifo_putc(fifo_conin, code);
+                                       state = 0;
+                               }
+                               break;
+                       case 6:
+                       case 7:
+                               if (isxdigit(ch)) {
+                                       ch = toupper(ch);
+                                       if (ch >= 'A')
+                                               ch -= 'A' - 10;
+                                       code = code * 16 + ch - '0';
+                                       state++;
+                               }
+                               if (state > 7) {
+                                       z80_memfifo_putc(fifo_conin, code);
+                                       state = 0;
                                }
-                               state = 0;
                                break;
                        }
                }
-
        }
 quit:
-
        return CMD_RET_SUCCESS;
 }
        
-

diff --git a/avr/cmd_misc.c b/avr/cmd_misc.c
index 7ab8fef0349e323aa7aad19171a9544c26835379..315b959bcebd97b1665373a003b5ff4804a182bf 100644 (file)
--- a/avr/cmd_misc.c
+++ b/avr/cmd_misc.c
@@ -6,13 +6,17 @@
  */
 
 #include "common.h"
+#include <stdlib.h>
+
 #include "command.h"
+#include "timer.h"
+#include "con-utils.h"
 
 
 command_ret_t do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
        uint_fast8_t putnl = 1;
-       
+
        (void) cmdtp; (void) flag;
 
        for (uint_fast8_t i = 1; i < argc; i++) {
@@ -20,11 +24,11 @@ command_ret_t do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                uint_fast8_t backslash = 0;
                char *p = argv[i];
                char c;
-               
+
                if (i != 1)
                        putchar(' ');
                while ((c = *p++) != '\0') {
-               
+
                        if(backslash) {
                                backslash = 0;
                                if (c == 'c') {
@@ -40,19 +44,48 @@ command_ret_t do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                        }
                        putchar(c);
                }
-       }                       
-                                       
+       }
+
        if (putnl)
                putchar('\n');
 
        return CMD_RET_SUCCESS;
 }
 
-#if 0
-U_BOOT_CMD(
-       echo,   CONFIG_SYS_MAXARGS,     1,      do_echo,
-       "echo args to console",
-       "[args..]\n"
-       "    - echo args to console; \\c suppresses newline"
-);
-#endif
+
+command_ret_t do_sleep(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+       unsigned long start = get_timer(0);
+       unsigned long delay;
+       char *sp;
+       uint_fast8_t millisec = 0;
+
+       (void) cmdtp; (void) flag;
+
+       if (argc != 2)
+               return CMD_RET_USAGE;
+
+       delay = strtoul(argv[1], &sp, 10);
+
+       if (*sp == 'm') {
+               millisec = 1;
+               sp++;
+       }
+       if (*sp == 's')
+               sp++;
+       if (*sp != '\0')
+               return CMD_RET_USAGE;
+
+       if (!millisec)
+               delay *= 1000;
+
+       while (get_timer(start) < delay) {
+               if (ctrlc())
+                       return CMD_RET_FAILURE;
+
+               udelay(100);
+       }
+
+       return CMD_RET_SUCCESS;
+}
+

diff --git a/avr/command_tbl.c b/avr/command_tbl.c
index 336e6ea3a068d66263519c1d9ebf1fdd014b5ff4..336c608b326c72a530a99e824ecaa4b52ce63a24 100644 (file)
--- a/avr/command_tbl.c
+++ b/avr/command_tbl.c
@@ -7,6 +7,7 @@
 
 extern command_ret_t do_help(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_echo(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_sleep(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_env_print(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_env_default(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_env_set(cmd_tbl_t *, int, int, char * const []);
@@ -62,6 +63,12 @@ CMD_TBL_ITEM(
        "[args..]\n"
        "     - echo args to console; \\c suppresses newline"
 ),
+CMD_TBL_ITEM(
+       sleep ,    2,    1,     do_sleep,
+       "delay execution for some time",
+       "N[m][s]\n"
+       "    - delay execution for decimal N (milli) seconds"
+),
 CMD_TBL_ITEM_COMPLETE(
        run,    CONFIG_SYS_MAXARGS,     1,      do_run,
        "run commands in an environment variable",

diff --git a/avr/i2c.c b/avr/i2c.c
index e0e5a1990b4086248752ecd9b0ccd6a9652aa4d9..d181ff60ee63fd2f48258866b469b2ec5aec4899 100644 (file)
--- a/avr/i2c.c
+++ b/avr/i2c.c
@@ -5,7 +5,6 @@
 
 #include "common.h"
 #include <avr/interrupt.h>
-#include <util/delay.h>
 #include <string.h>
 
 #include "config.h"

diff --git a/avr/main.c b/avr/main.c
index 34db6eff9eb4bcfd9103839e57b83873662380e8..2f9a62f284094ac87e76d74db8dda13c0891f508 100644 (file)
--- a/avr/main.c
+++ b/avr/main.c
@@ -4,7 +4,6 @@
 
 #include "common.h"
 
-#include <util/delay.h>
 #include <avr/interrupt.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -20,8 +19,6 @@
 #include "env.h"
 #include "z180-serv.h"
 
-#define udelay(n)  _delay_us(n)
-
 static uint8_t mcusr;
 
 /*--------------------------------------------------------------------------*/

diff --git a/avr/pin.c b/avr/pin.c
index 14896b31901ea59c99464b1431dcfaa3cd6b699d..6e88aa576c561f280aecc82a57be5f44070e4502 100644 (file)
--- a/avr/pin.c
+++ b/avr/pin.c
@@ -130,14 +130,14 @@ int pin_config(int pin, pinmode_t mode)
                switch (mode) {
                case INPUT:
                        pin_timer_off(pinlist[pin].timer);
-                       ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+                       ATOMIC_BLOCK(ATOMIC_FORCEON) {
                                p->ddr &= ~bit;
                                p->pout &= ~bit;
                        }
                        break;
                case INPUT_PULLUP:
                        pin_timer_off(pinlist[pin].timer);
-                       ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+                       ATOMIC_BLOCK(ATOMIC_FORCEON) {
                                p->ddr &= ~bit;
                                p->pout |= bit;
                        }
@@ -145,7 +145,7 @@ int pin_config(int pin, pinmode_t mode)
                case OUTPUT:
                        pin_timer_off(pinlist[pin].timer);
                case OUTPUT_TIMER:
-                       ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+                       ATOMIC_BLOCK(ATOMIC_FORCEON) {
                                p->ddr |= bit;
                        }
                        break;
@@ -162,7 +162,7 @@ void pin_write(int pin, uint8_t val)
        port_t *p = pinlist[pin].adr;
        uint8_t bit = pinlist[pin].mask;
        
-       ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+       ATOMIC_BLOCK(ATOMIC_FORCEON) {
                if (val)
                        p->pout |= bit;
                else

diff --git a/avr/z180-serv.c b/avr/z180-serv.c
index 56852cb4e4bb29e484cd63548a345a5b6ce60a52..e6b4efdf2ac1c37238ee4b98c25709b5740ec540 100644 (file)
--- a/avr/z180-serv.c
+++ b/avr/z180-serv.c
@@ -1,6 +1,3 @@
-/*
- */
-
 #include "common.h"
 #include <util/atomic.h>
 
@@ -18,11 +15,11 @@
 uint8_t z80_get_byte(uint32_t adr)
 {
        uint8_t data;
-       
+
        z80_bus_cmd(Request);
        data = z80_read(adr);
        z80_bus_cmd(Release);
-       
+
        return data;
 }
 
@@ -101,12 +98,12 @@ void do_message(int len, uint8_t *msg)
                                                fct, sub_fct);
                                return; /* TODO: unknown message # */
                        }
-               
+
                        ++i;
                }
 
                while (fct == z80_messages[i].fct) {
-                       if (sub_fct >= z80_messages[i].sub_min && 
+                       if (sub_fct >= z80_messages[i].sub_min &&
                                        sub_fct <= z80_messages[i].sub_max )
                                break;
                        ++i;
@@ -169,12 +166,12 @@ void check_msg_fifo(void)
 int msg_handling(int state)
 {
        uint8_t pending;
-       
-       ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+
+       ATOMIC_BLOCK(ATOMIC_FORCEON) {
                pending = (Stat & S_MSG_PENDING) != 0;
                Stat &= ~S_MSG_PENDING;
        }
-               
+
        if (pending) {
                switch (state) {
                case 0:
@@ -196,37 +193,14 @@ int msg_handling(int state)
 
        return state;
 }
-       
-
-int console_handling(int state)
-{
-       int ch;
-       uint8_t pending;
-       
-       ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
-               pending = (Stat & S_CON_PENDING) != 0;
-               Stat &= ~S_CON_PENDING;
-       }
-               
-       if (pending) {
-               while ((ch = z80_memfifo_getc(fifo_conout)) >= 0) {
-                       putchar(ch);
-               }
-       }
-
-       return state;
-}
-       
-
 
 
 static int handle_msg_handling;
 
 void setup_z180_serv(void)
 {
-               
+
        handle_msg_handling = bg_register(msg_handling, 0);
-//     bg_register(console_handling, 0);
 }
 
 void restart_z180_serv(void)
@@ -236,7 +210,9 @@ void restart_z180_serv(void)
        z80_write(0x41, 0);
        z80_write(0x42, 0);
        z80_bus_cmd(Release);
-               
+
+       for (int i = 0; i < NUM_FIFOS; i++)
+               z80_memfifo_init(i, 0);
        bg_setstat(handle_msg_handling, 0);
 }
 
@@ -295,13 +271,13 @@ const FLASH uint8_t test1[] = {
        0x21, 0x1E, 0x00,  //   ld      hl,dmclrt       ;load DMA registers
        0x06, 0x08,        //   ld      b,dmct_e-dmclrt
        0x0E, 0x20,        //   ld      c,sar0l
-       0xED, 0x93,        //   otimr   
+       0xED, 0x93,        //   otimr
        0x3E, 0xC3,        //   ld      a,0c3h          ;dst +1, src +1, burst
        0xED, 0x39, 0x31,  //   out0    (dmode),a       ;
-       0x3E, 0x62,        //   ld      a,062h          ;enable dma0, 
+       0x3E, 0x62,        //   ld      a,062h          ;enable dma0,
        0xED, 0x39, 0x30,  //cl_1:      out0    (dstat),a       ;copy 64k
        0x18, 0xFB,        //   jr      cl_1            ;
-       0x00, 0x00,        //dmclrt:    dw      0               ;src (inc) 
+       0x00, 0x00,        //dmclrt:    dw      0               ;src (inc)
        0x00,              //   db      0               ;src
        0x00, 0x00,        //   dw      0               ;dst (inc),
        0x00,              //   db      0               ;dst

diff --git a/avr/z80-if.c b/avr/z80-if.c
index 414582e7a28c35fe45f0b019fd92f9b4cfad7419..9492c28d6fd14a1eab7c697656e54dd3b23ab3d0 100644 (file)
--- a/avr/z80-if.c
+++ b/avr/z80-if.c
@@ -54,7 +54,6 @@
  */
 
 #include <avr/io.h>
-#include <util/delay.h>
 #include <util/atomic.h>
 #include <stdio.h>
 #include "debug.h"
@@ -241,7 +240,7 @@ static void z80_busreq_hpulse(void)
        z80_dbus_set_in();
        z80_addrbus_set_tristate();
 
-       ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+       ATOMIC_BLOCK(ATOMIC_FORCEON) {
                Z80_O_BUSREQ = 1;
                Z80_O_BUSREQ = 1;       /* 2 AVR clock cycles */
                Z80_O_BUSREQ = 0;       /* 2 AVR clock cycles */
@@ -497,20 +496,20 @@ static struct {
        } fifo_dsc[NUM_FIFOS];
 
 
-void z80_memfifo_init(const fifo_t f, uint32_t adr)
+void z80_memfifo_init(const fifo_t f, uint32_t addr)
 {
+       fifo_dsc[f].base = addr;
 
-DBG_P(2, "z80_memfifo_init: %i, %lx\n", f, adr);
+       if (addr != 0) {
 
-       fifo_dsc[f].base = adr;
+DBG_P(2, "z80_memfifo_init: %i, %lx\n", f, addr);
 
-       z80_bus_cmd(Request);
-
-       fifo_dsc[f].mask = z80_read(adr + FIFO_BUFSIZE_MASK);
-       fifo_dsc[f].idx_in = z80_read(adr + FIFO_INDEX_IN);
-       fifo_dsc[f].idx_out = z80_read(adr + FIFO_INDEX_OUT);
-
-       z80_bus_cmd(Release);
+               z80_bus_cmd(Request);
+               fifo_dsc[f].mask = z80_read(addr + FIFO_BUFSIZE_MASK);
+               fifo_dsc[f].idx_in = z80_read(addr + FIFO_INDEX_IN);
+               fifo_dsc[f].idx_out = z80_read(addr + FIFO_INDEX_OUT);
+               z80_bus_cmd(Release);
+       }
 }
 
 

diff --git a/include/common.h b/include/common.h
index 74339df76dd0ce24d336ea5a50c434705ee41e2e..121922f390389baf54b49e3857a20c29666605fe 100644 (file)
--- a/include/common.h
+++ b/include/common.h
@@ -4,6 +4,9 @@
 #ifdef __AVR__
 #include <avr/io.h>
 #include <avr/pgmspace.h>
+#include <util/delay.h>
+
+#define udelay(n)  _delay_us(n)
 
 //TODO:
 //  Known to work: 4.8.4, 4.9.1
@@ -38,8 +41,8 @@ extern volatile uint_least8_t Stat;
 #endif /* __AVR__ */
 
 #define S_10MS_TO      (1<<0)
-#define S_MSG_PENDING  (2<<0)
-#define S_CON_PENDING  (3<<0)
+#define S_MSG_PENDING  (1<<1)
+#define S_CON_PENDING  (1<<2)
 
 static inline 
 void my_puts(const char *s)