gdb: Fixed a warning
[simavr] / simavr / sim / sim_avr.c
index b00cfc7..de3ea41 100644 (file)
 #include <unistd.h>
 #include "sim_avr.h"
 #include "sim_core.h"
+#include "sim_time.h"
 #include "sim_gdb.h"
 #include "avr_uart.h"
 #include "sim_vcd_file.h"
 #include "avr_mcu_section.h"
 
+#define AVR_KIND_DECL
+#include "sim_core_decl.h"
 
 int avr_init(avr_t * avr)
 {
@@ -52,6 +55,7 @@ int avr_init(avr_t * avr)
        avr->run = avr_callback_run_raw;
        avr->sleep = avr_callback_sleep_raw;
        avr->state = cpu_Running;
+       avr->log = 1;
        avr_reset(avr); 
        return 0;
 }
@@ -80,7 +84,8 @@ void avr_reset(avr_t * avr)
                avr->sreg[i] = 0;
        if (avr->reset)
                avr->reset(avr);
-
+       avr_interrupt_reset(avr);
+       avr_cycle_timer_reset(avr);
        avr_io_t * port = avr->io_port;
        while (port) {
                if (port->reset)
@@ -99,7 +104,7 @@ void avr_sadly_crashed(avr_t *avr, uint8_t signal)
                        avr_gdb_init(avr);
        } 
        if (!avr->gdb)
-               exit(1); // no gdb ?
+               avr->state = cpu_Crashed;
 }
 
 static void _avr_io_command_write(struct avr_t * avr, avr_io_addr_t addr, uint8_t v, void * param)
@@ -137,15 +142,19 @@ static void _avr_io_console_write(struct avr_t * avr, avr_io_addr_t addr, uint8_
        static char * buf = NULL;
        static int size = 0, len = 0;
 
-       if (v == '\r') {
+       if (v == '\r' && buf) {
+               buf[len] = 0;
                printf("O:" "%s" "" "\n", buf);
                fflush(stdout);
+               len = 0;
+               return;
        }
        if (len + 1 >= size) {
                size += 128;
                buf = (char*)realloc(buf, size);
        }
-       buf[len++] = v;
+       if (v >= ' ')
+               buf[len++] = v;
 }
 
 void avr_set_console_register(avr_t * avr, avr_io_addr_t addr)
@@ -154,7 +163,7 @@ void avr_set_console_register(avr_t * avr, avr_io_addr_t addr)
                avr_register_io_write(avr, addr, _avr_io_console_write, NULL);
 }
 
-void avr_loadcode(avr_t * avr, uint8_t * code, uint32_t size, uint32_t address)
+void avr_loadcode(avr_t * avr, uint8_t * code, uint32_t size, avr_flashaddr_t address)
 {
        if (size > avr->flashend+1) {
                fprintf(stderr, "avr_loadcode(): Attempted to load code of size %d but flash size is only %d.\n",
@@ -183,7 +192,7 @@ void avr_callback_run_gdb(avr_t * avr)
        if (step)
                avr->state = cpu_Running;
        
-       uint16_t new_pc = avr->pc;
+       avr_flashaddr_t new_pc = avr->pc;
 
        if (avr->state == cpu_Running) {
                new_pc = avr_run_one(avr);
@@ -195,10 +204,10 @@ void avr_callback_run_gdb(avr_t * avr)
        // if we just re-enabled the interrupts...
        // double buffer the I flag, to detect that edge
        if (avr->sreg[S_I] && !avr->i_shadow)
-               avr->pending_wait++;
+               avr->interrupts.pending_wait++;
        avr->i_shadow = avr->sreg[S_I];
 
-       // run the cycle timers, get the suggested sleeo time
+       // run the cycle timers, get the suggested sleep time
        // until the next timer is due
        avr_cycle_count_t sleep = avr_cycle_timer_process(avr);
 
@@ -206,9 +215,11 @@ void avr_callback_run_gdb(avr_t * avr)
 
        if (avr->state == cpu_Sleeping) {
                if (!avr->sreg[S_I]) {
-                       printf("simavr: sleeping with interrupts off, quitting gracefully\n");
+                       if (avr->log)
+                               printf("simavr: sleeping with interrupts off, quitting gracefully\n");
                        avr_terminate(avr);
-                       exit(0);
+                       avr->state = cpu_Done;
+                       return;
                }
                /*
                 * try to sleep for as long as we can (?)
@@ -234,8 +245,7 @@ void avr_callback_sleep_raw(avr_t * avr, avr_cycle_count_t howLong)
 
 void avr_callback_run_raw(avr_t * avr)
 {
-
-       uint16_t new_pc = avr->pc;
+       avr_flashaddr_t new_pc = avr->pc;
 
        if (avr->state == cpu_Running) {
                new_pc = avr_run_one(avr);
@@ -247,7 +257,7 @@ void avr_callback_run_raw(avr_t * avr)
        // if we just re-enabled the interrupts...
        // double buffer the I flag, to detect that edge
        if (avr->sreg[S_I] && !avr->i_shadow)
-               avr->pending_wait++;
+               avr->interrupts.pending_wait++;
        avr->i_shadow = avr->sreg[S_I];
 
        // run the cycle timers, get the suggested sleeo time
@@ -258,9 +268,11 @@ void avr_callback_run_raw(avr_t * avr)
 
        if (avr->state == cpu_Sleeping) {
                if (!avr->sreg[S_I]) {
-                       printf("simavr: sleeping with interrupts off, quitting gracefully\n");
+                       if (avr->log)
+                               printf("simavr: sleeping with interrupts off, quitting gracefully\n");
                        avr_terminate(avr);
-                       exit(0);
+                       avr->state = cpu_Done;
+                       return;
                }
                /*
                 * try to sleep for as long as we can (?)
@@ -280,25 +292,34 @@ int avr_run(avr_t * avr)
        return avr->state;
 }
 
-
+#if 0
 extern avr_kind_t tiny13;
 extern avr_kind_t tiny2313;
 extern avr_kind_t tiny25,tiny45,tiny85;
 extern avr_kind_t tiny24,tiny44,tiny84;
+extern avr_kind_t mega8;
 extern avr_kind_t mega48,mega88,mega168,mega328;
 extern avr_kind_t mega164,mega324,mega644;
 extern avr_kind_t mega128;
+extern avr_kind_t mega1281;
+extern avr_kind_t mega16m1;
+extern avr_kind_t usb162;
 
 avr_kind_t * avr_kind[] = {
        &tiny13,
        &tiny2313,
        &tiny25, &tiny45, &tiny85,
        &tiny24, &tiny44, &tiny84,
+       &mega8,
        &mega48, &mega88, &mega168, &mega328,
        &mega164, &mega324, &mega644,
        &mega128,
+       &mega1281,
+       &mega16m1,
+       &usb162,
        NULL
 };
+#endif
 
 avr_t * avr_make_mcu_by_name(const char *name)
 {