Disable all peripheral functions globally. Enable used functions when needed.

[z180-stamp.git] / stm32 / z180-stamp-stm32.c

diff --git a/stm32/z180-stamp-stm32.c b/stm32/z180-stamp-stm32.c
index f55e076a8444e6a5d378f3452d651349cc856a2f..15d732d26733f75fbdc6875cb2c62f2e43eff700 100644 (file)
--- a/stm32/z180-stamp-stm32.c
+++ b/stm32/z180-stamp-stm32.c
@@ -18,8 +18,7 @@
 #include "debug.h"
 #include "serial.h"
 #include "z80-if.h"
-#include "hdrom.h"
-
+#include "../z180/hdrom.h"
 
 #define ESCCHAR                ('^'-0x40)
 
@@ -320,10 +319,10 @@ static void key_timerproc() {
 
 void sys_tick_handler(void)
 {
-       static int tick_10ms = 0;
-       static int count_ms = 0;
+       static int_fast8_t tick_10ms = 0;
+       static int_fast16_t count_ms = 0;
 
-       int i;
+       int_fast8_t i;
 
        ++tick_10ms;
        if (tick_10ms == 10)
@@ -390,10 +389,10 @@ void tim3_set(int mode)
 
 /*--------------------------------------------------------------------------*/
 
-static uint32_t z80_sram_cmp(uint32_t addr, int length, uint8_t wval, int inc)
+static uint32_t z80_sram_cmp(uint32_t addr, uint32_t length, uint8_t wval, int inc)
 {
        uint8_t rval;
-       int errors = 0;
+       int_fast8_t errors = 0;
        
        DBG_P(1, "SRAM: Check %#.5x byte... ", length);
        while (length--) {
@@ -503,82 +502,113 @@ static void do_10ms(void)
        }
 }
 
-static
-void do_msg_init(int len, uint8_t* msg)
+struct msg_item {
+       uint8_t fct;
+       uint8_t sub_min, sub_max;
+       void (*func)(uint8_t, int, uint8_t *);
+};
+
+uint32_t msg_to_addr(uint8_t *msg)
 {
-       uint8_t sub_fct;
-
-       if (len > 0) {
-               len--;
-               switch (sub_fct = *msg++) {
-               case 0:
-               case 1:
-               case 2:
-                       if (len == 3) {
-                               uint32_t fifoadr = 0;
-                               while (len--)
-                                       fifoadr = (fifoadr << 8) + msg[len];
-                               if (sub_fct == 0)
-                                       z80_init_msg_fifo(fifoadr);
-                               else
-                                       z80_memfifo_init(sub_fct - 1, fifoadr);
-                       } else {
-                               /* garbage from z180 */
-                       }
-                       break;
-               default:
-                       /* garbage from z180 */
-                       break;
-               }
-       }
+       uint32_t addr = msg[0] | (msg[1] << 8) | ((uint32_t)msg[2] << 16);
+
+       return addr;
+
 }
 
-static
-void do_msg_char(int len, uint8_t* msg)
+void do_msg_ini_msgfifo(uint8_t subf, int len, uint8_t * msg)
 {
-       uint8_t sub_fct;
-
-       if (len > 0) {
-               len--;
-               switch (sub_fct = *msg++) {
-               case 1: /* console output */
-                       while (len--)
-                               putchar(*msg++);
-                       break;
-               }
-       }
+       (void)subf; (void)len;
+
+       z80_init_msg_fifo(msg_to_addr(msg));
+}
+
+
+void do_msg_ini_memfifo(uint8_t subf, int len, uint8_t * msg)
+{
+       (void)len;
+
+       z80_memfifo_init(subf - 1, msg_to_addr(msg));
+}
+
+
+void do_msg_char_out(uint8_t subf, int len, uint8_t * msg)
+{
+       (void)subf;
+
+       while (len--)
+               putchar(*msg++);
 }
 
-static
+
+const struct msg_item z80_messages[] =
+{
+       { 0,                    /* fct nr. */
+         0, 0,                 /* sub fct nr. from, to */
+         &do_msg_ini_msgfifo},
+       { 0,
+         1, 2,
+         &do_msg_ini_memfifo},
+       { 1,
+         1, 1,
+         &do_msg_char_out},
+       { 0xff,                         /* end mark */
+         0, 0,
+         0},
+
+};
+
+
+
+
 void do_message(int len, uint8_t *msg)
 {
-       uint8_t sub_fct;
+       uint8_t fct, sub_fct;
+       int_fast8_t i = 0;
 
-       if (len > 0) {
-               len--;
-               switch (*msg++) {
-               case 0: /* init functions */
-                       do_msg_init(len, msg);
-                       break;
-               case 1: /* character i/o functions */
-                       do_msg_char(len, msg);
-                       break;
-               default:
-                       /* no more functions definded yet*/
-                       break;
+       if (len >= 2) {
+               fct = *msg++;
+               sub_fct = *msg++;
+               len -= 2;
+
+               while (fct != z80_messages[i].fct)
+                       ++i;
+
+               if (z80_messages[i].fct == 0xff) {
+                       DBG_P(1, "do_message: Unknown function: %i, %i\n",
+                                       fct, sub_fct);
+                       return; /* TODO: unknown message # */
                }
+
+               while (fct == z80_messages[i].fct) {
+                       if (sub_fct >= z80_messages[i].sub_min && sub_fct <= z80_messages[i].sub_max )
+                               break;
+                       ++i;
+               }
+
+               if (z80_messages[i].fct != fct) {
+                       DBG_P(1, "do_message: Unknown sub function: %i, %i\n",
+                                       fct, sub_fct);
+                       return; /* TODO: unknown message sub# */
+               }
+
+               (z80_messages[i].func)(sub_fct, len, msg);
+
+
        } else {
-               /* shoudn't happen */
+               /* TODO: error */
+               DBG_P(1, "do_message: to few arguments (%i); this shouldn't happen!\n", len);
        }
 }
 
 
-#define CTRBUF_LEN 20
 
-static void check_msg_fifo(void)
+#define CTRBUF_LEN 256
+
+void check_msg_fifo(void)
 {
        int ch;
-       static int state;
+       static int_fast8_t state;
        static int msglen,idx;
        static uint8_t buffer[CTRBUF_LEN];
 
@@ -615,12 +645,11 @@ static void check_msg_fifo(void)
 
 void z80_load_mem(void)
 {
-
-DBG_P(1, "Loading z80 memory... \n");
-
        unsigned sec = 0;
        uint32_t sec_base = hdrom_start;
 
+       DBG_P(1, "Loading z80 memory... \n");
+
        while (sec < hdrom_sections) {
                DBG_P(2, "  From: 0x%.5lX to: 0x%.5lX    (%5li bytes)\n",
                                hdrom_address[sec],
@@ -638,11 +667,7 @@ DBG_P(1, "Loading z80 memory... \n");
 
 int main(void)
 {
-       //uint32_t led_state = LED_BLUE_PIN;
-       //uint32_t rc;
-       //uint8_t startval = 0;
-       //int count;
-       int state = 0;
+       int_fast8_t state = 0;
        int ch;
 
        clock_setup();
@@ -674,7 +699,7 @@ int main(void)
        
        z80_memset(0, 0x76, 0x80000);
        //z80_sram_fill(0, 512 * 1024, 0x76, 0);
-       z80_sram_cmp(0, 512 * 1024, 0x76, 0);
+       z80_sram_cmp(0, (uint32_t)512 * 1024, 0x76, 0);
        
        z80_load_mem();
        z80_reset(LOW);