regbits: Added a "raw" variant to get/set

[simavr] / simavr / sim / sim_avr.c

diff --git a/simavr/sim/sim_avr.c b/simavr/sim/sim_avr.c
index 7f7a3ab..e13117d 100644 (file)
--- a/simavr/sim/sim_avr.c
+++ b/simavr/sim/sim_avr.c
@@ -45,6 +45,9 @@ int avr_init(avr_t * avr)
                avr->special_init(avr);
        if (avr->init)
                avr->init(avr);
+       // set default (non gdb) fast callbacks
+       avr->run = avr_callback_run_raw;
+       avr->sleep = avr_callback_sleep_raw;
        avr->state = cpu_Running;
        avr_reset(avr); 
        return 0;
@@ -150,16 +153,27 @@ void avr_set_console_register(avr_t * avr, avr_io_addr_t addr)
 
 void avr_loadcode(avr_t * avr, uint8_t * code, uint32_t size, uint32_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",
+                       size, avr->flashend+1);
+               abort();
+       }
        memcpy(avr->flash + address, code, size);
 }
 
+void avr_callback_sleep_gdb(avr_t * avr, avr_cycle_count_t howLong)
+{
+       uint32_t usec = avr_cycles_to_usec(avr, howLong);
+       while (avr_gdb_processor(avr, usec))
+               ;
+}
 
-int avr_run(avr_t * avr)
+void avr_callback_run_gdb(avr_t * avr)
 {
        avr_gdb_processor(avr, avr->state == cpu_Stopped);
 
        if (avr->state == cpu_Stopped)
-               return avr->state;
+               return ;
 
        // if we are stepping one instruction, we "run" for one..
        int step = avr->state == cpu_Step;
@@ -196,13 +210,7 @@ int avr_run(avr_t * avr)
                /*
                 * try to sleep for as long as we can (?)
                 */
-               uint32_t usec = avr_cycles_to_usec(avr, sleep);
-       //      printf("sleep usec %d cycles %d\n", usec, sleep);
-               if (avr->gdb) {
-                       while (avr_gdb_processor(avr, usec))
-                               ;
-               } else
-                       usleep(usec);
+               avr->sleep(avr, sleep);
                avr->cycle += 1 + sleep;
        }
        // Interrupt servicing might change the PC too, during 'sleep'
@@ -213,6 +221,59 @@ int avr_run(avr_t * avr)
        if (step)
                avr->state = cpu_StepDone;
 
+}
+
+void avr_callback_sleep_raw(avr_t * avr, avr_cycle_count_t howLong)
+{
+       uint32_t usec = avr_cycles_to_usec(avr, howLong);
+       usleep(usec);
+}
+
+void avr_callback_run_raw(avr_t * avr)
+{
+
+       uint16_t new_pc = avr->pc;
+
+       if (avr->state == cpu_Running) {
+               new_pc = avr_run_one(avr);
+#if CONFIG_SIMAVR_TRACE
+               avr_dump_state(avr);
+#endif
+       }
+
+       // 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->i_shadow = avr->sreg[S_I];
+
+       // run the cycle timers, get the suggested sleeo time
+       // until the next timer is due
+       avr_cycle_count_t sleep = avr_cycle_timer_process(avr);
+
+       avr->pc = new_pc;
+
+       if (avr->state == cpu_Sleeping) {
+               if (!avr->sreg[S_I]) {
+                       printf("simavr: sleeping with interrupts off, quitting gracefully\n");
+                       avr_terminate(avr);
+                       exit(0);
+               }
+               /*
+                * try to sleep for as long as we can (?)
+                */
+               avr->sleep(avr, sleep);
+               avr->cycle += 1 + sleep;
+       }
+       // Interrupt servicing might change the PC too, during 'sleep'
+       if (avr->state == cpu_Running || avr->state == cpu_Sleeping)
+               avr_service_interrupts(avr);
+}
+
+
+int avr_run(avr_t * avr)
+{
+       avr->run(avr);
        return avr->state;
 }
 
@@ -220,6 +281,7 @@ int avr_run(avr_t * avr)
 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 mega48,mega88,mega168,mega328;
 extern avr_kind_t mega164,mega324,mega644;
 extern avr_kind_t mega128;
@@ -228,6 +290,7 @@ avr_kind_t * avr_kind[] = {
        &tiny13,
        &tiny2313,
        &tiny25, &tiny45, &tiny85,
+       &tiny24, &tiny44, &tiny84,
        &mega48, &mega88, &mega168, &mega328,
        &mega164, &mega324, &mega644,
        &mega128,