--- uae/src/cia.c	2018/04/24 16:51:25	1.1.1.7
+++ uae/src/cia.c	2018/04/24 17:01:57	1.1.1.12
@@ -13,7 +13,7 @@
 
 #include "config.h"
 #include "options.h"
-#include "threaddep/penguin.h"
+#include "threaddep/thread.h"
 #include "events.h"
 #include "memory.h"
 #include "custom.h"
@@ -23,8 +23,9 @@
 #include "xwin.h"
 #include "keybuf.h"
 #include "gui.h"
+#include "savestate.h"
 
-#define DIV10 5 /* Yes, a bad identifier. */
+#define DIV10 (5*CYCLE_UNIT) /* Yes, a bad identifier. */
 
 /* battclock stuff */
 #define RTC_D_ADJ      8
@@ -44,27 +45,32 @@ static unsigned int clock_control_d = RT
 static unsigned int clock_control_e = 0;
 static unsigned int clock_control_f = RTC_F_24_12;
 
-unsigned int ciaaicr,ciaaimask,ciabicr,ciabimask;
-unsigned int ciaacra,ciaacrb,ciabcra,ciabcrb;
-unsigned long ciaata,ciaatb,ciabta,ciabtb;
-unsigned long ciaatod,ciabtod,ciaatol,ciabtol,ciaaalarm,ciabalarm;
-int ciaatlatch,ciabtlatch;
+unsigned int ciaaicr, ciaaimask, ciabicr, ciabimask;
+unsigned int ciaacra, ciaacrb, ciabcra, ciabcrb;
+
+/* Values of the CIA timers.  */
+unsigned long ciaata, ciaatb, ciabta, ciabtb;
+/* Computed by compute_passed_time.  */
+unsigned long ciaata_passed, ciaatb_passed, ciabta_passed, ciabtb_passed;
+
+unsigned long ciaatod, ciabtod, ciaatol, ciabtol, ciaaalarm, ciabalarm;
+int ciaatlatch, ciabtlatch;
 
 unsigned int ciabpra;
 
 unsigned int gui_ledstate;
 
-static unsigned long ciaala,ciaalb,ciabla,ciablb;
+static unsigned long ciaala, ciaalb, ciabla, ciablb;
 static int ciaatodon, ciabtodon;
-static unsigned int ciaapra,ciaaprb,ciaadra,ciaadrb,ciaasdr;
-static unsigned int ciabprb,ciabdra,ciabdrb,ciabsdr;
+static unsigned int ciaapra, ciaaprb, ciaadra, ciaadrb, ciaasdr;
+static unsigned int ciabprb, ciabdra, ciabdrb, ciabsdr;
 static int div10;
 static int kbstate, kback, ciaasdr_unread = 0;
 
 static int prtopen;
 static FILE *prttmp;
 
-static void setclr(unsigned int *p, unsigned int val)
+static void setclr (unsigned int *p, unsigned int val)
 {
     if (val & 0x80) {
 	*p |= val & 0x7F;
@@ -73,18 +79,18 @@ static void setclr(unsigned int *p, unsi
     }
 }
 
-static void RethinkICRA(void)
+static void RethinkICRA (void)
 {
     if (ciaaimask & ciaaicr) {
 	ciaaicr |= 0x80;
-	custom_bank.wput(0xDFF09C,0x8008);
+	INTREQ_0 (0x8008);
     } else {
 	ciaaicr &= 0x7F;
 /*	custom_bank.wput(0xDFF09C,0x0008);*/
     }
 }
 
-static void RethinkICRB(void)
+static void RethinkICRB (void)
 {
 #if 0 /* ??? What's this then? */
     if (ciabicr & 0x10) {
@@ -93,28 +99,66 @@ static void RethinkICRB(void)
 #endif
     if (ciabimask & ciabicr) {
 	ciabicr |= 0x80;
-	custom_bank.wput(0xDFF09C,0xA000);
+	INTREQ_0 (0xA000);
     } else {
 	ciabicr &= 0x7F;
 /*	custom_bank.wput(0xDFF09C,0x2000);*/
     }
 }
 
-static int lastdiv10;
+void rethink_cias (void)
+{
+    RethinkICRA ();
+    RethinkICRB ();
+}
+
+/* Figure out how many CIA timer cycles have passed for each timer since the
+   last call of CIA_calctimers.  */
 
-static void CIA_update(void)
+static void compute_passed_time (void)
 {
-    unsigned long int ccount = cycles - eventtab[ev_cia].oldcycles + lastdiv10;
+    unsigned long int ccount = (get_cycles () - eventtab[ev_cia].oldcycles + div10);
+    unsigned long int ciaclocks = ccount / DIV10;
+
+    ciaata_passed = ciaatb_passed = ciabta_passed = ciabtb_passed = 0;
+
+    /* CIA A timers */
+    if ((ciaacra & 0x21) == 0x01) {
+	assert ((ciaata+1) >= ciaclocks);
+	ciaata_passed = ciaclocks;
+    }
+    if ((ciaacrb & 0x61) == 0x01) {
+	assert ((ciaatb+1) >= ciaclocks);
+	ciaatb_passed = ciaclocks;
+    }
+
+    /* CIA B timers */
+    if ((ciabcra & 0x21) == 0x01) {
+	assert ((ciabta+1) >= ciaclocks);
+	ciabta_passed = ciaclocks;
+    }
+    if ((ciabcrb & 0x61) == 0x01) {
+	assert ((ciabtb+1) >= ciaclocks);
+	ciabtb_passed = ciaclocks;
+    }
+}
+
+/* Called to advance all CIA timers to the current time.  This expects that
+   one of the timer values will be modified, and CIA_calctimers will be called
+   in the same cycle.  */
+
+static void CIA_update (void)
+{
+    unsigned long int ccount = (get_cycles () - eventtab[ev_cia].oldcycles + div10);
     unsigned long int ciaclocks = ccount / DIV10;
 
     int aovfla = 0, aovflb = 0, bovfla = 0, bovflb = 0;
 
-    lastdiv10 = div10;
     div10 = ccount % DIV10;
 
     /* CIA A timers */
     if ((ciaacra & 0x21) == 0x01) {
-	assert((ciaata+1) >= ciaclocks);
+	assert ((ciaata+1) >= ciaclocks);
 	if ((ciaata+1) == ciaclocks) {
 	    aovfla = 1;
 	    if ((ciaacrb & 0x61) == 0x41) {
@@ -124,14 +168,14 @@ static void CIA_update(void)
 	ciaata -= ciaclocks;
     }
     if ((ciaacrb & 0x61) == 0x01) {
-	assert((ciaatb+1) >= ciaclocks);
+	assert ((ciaatb+1) >= ciaclocks);
 	if ((ciaatb+1) == ciaclocks) aovflb = 1;
 	ciaatb -= ciaclocks;
     }
 
     /* CIA B timers */
     if ((ciabcra & 0x21) == 0x01) {
-	assert((ciabta+1) >= ciaclocks);
+	assert ((ciabta+1) >= ciaclocks);
 	if ((ciabta+1) == ciaclocks) {
 	    bovfla = 1;
 	    if ((ciabcrb & 0x61) == 0x41) {
@@ -167,14 +211,15 @@ static void CIA_update(void)
     }
 }
 
-static void CIA_calctimers(void)
-{
-    int ciaatimea = -1, ciaatimeb = -1, ciabtimea = -1, ciabtimeb = -1;
+/* Call this only after CIA_update has been called in the same cycle.  */
 
-    eventtab[ev_cia].oldcycles = cycles;
+static void CIA_calctimers (void)
+{
+    long ciaatimea = -1, ciaatimeb = -1, ciabtimea = -1, ciabtimeb = -1;
 
+    eventtab[ev_cia].oldcycles = get_cycles ();
     if ((ciaacra & 0x21) == 0x01) {
-	ciaatimea = (DIV10-div10) + DIV10*ciaata;
+	ciaatimea = (DIV10 - div10) + DIV10 * ciaata;
     }
     if ((ciaacrb & 0x61) == 0x41) {
 	/* Timer B will not get any pulses if Timer A is off. */
@@ -188,11 +233,11 @@ static void CIA_calctimers(void)
 	}
     }
     if ((ciaacrb & 0x61) == 0x01) {
-	ciaatimeb = (DIV10-div10) + DIV10*ciaatb;
+	ciaatimeb = (DIV10 - div10) + DIV10 * ciaatb;
     }
 
     if ((ciabcra & 0x21) == 0x01) {
-	ciabtimea = (DIV10-div10) + DIV10*ciabta;
+	ciabtimea = (DIV10 - div10) + DIV10 * ciabta;
     }
     if ((ciabcrb & 0x61) == 0x41) {
 	/* Timer B will not get any pulses if Timer A is off. */
@@ -206,7 +251,7 @@ static void CIA_calctimers(void)
 	}
     }
     if ((ciabcrb & 0x61) == 0x01) {
-	ciabtimeb = (DIV10-div10) + DIV10*ciabtb;
+	ciabtimeb = (DIV10 - div10) + DIV10 * ciabtb;
     }
     eventtab[ev_cia].active = (ciaatimea != -1 || ciaatimeb != -1
 			       || ciabtimea != -1 || ciabtimeb != -1);
@@ -216,27 +261,24 @@ static void CIA_calctimers(void)
 	if (ciaatimeb != -1 && ciaatimeb < ciatime) ciatime = ciaatimeb;
 	if (ciabtimea != -1 && ciabtimea < ciatime) ciatime = ciabtimea;
 	if (ciabtimeb != -1 && ciabtimeb < ciatime) ciatime = ciabtimeb;
-	eventtab[ev_cia].evtime = ciatime + cycles;
+	eventtab[ev_cia].evtime = ciatime + get_cycles ();
     }
     events_schedule();
 }
 
-void CIA_handler(void)
+void CIA_handler (void)
 {
-    CIA_update();
-    CIA_calctimers();
+    CIA_update ();
+    CIA_calctimers ();
 }
 
-void diskindex_handler(void)
+void cia_diskindex (void)
 {
-    eventtab[ev_diskindex].evtime += cycles - eventtab[ev_diskindex].oldcycles;
-    eventtab[ev_diskindex].oldcycles = cycles;
-/*    printf(".\n");*/
     ciabicr |= 0x10;
     RethinkICRB();
 }
 
-void CIA_hsync_handler(void)
+void CIA_hsync_handler (void)
 {
     static unsigned int keytime = 0, sleepyhead = 0;
 
@@ -290,7 +332,7 @@ void CIA_hsync_handler(void)
     }
 }
 
-void CIA_vsync_handler()
+void CIA_vsync_handler ()
 {
     if (ciaatodon)
 	ciaatod++;
@@ -304,11 +346,13 @@ void CIA_vsync_handler()
     serial_flush_buffer();
 }
 
-static uae_u8 ReadCIAA(unsigned int addr)
+static uae_u8 ReadCIAA (unsigned int addr)
 {
     unsigned int tmp;
 
-    switch(addr & 0xf) {
+    compute_passed_time ();
+    
+    switch (addr & 0xf) {
     case 0:
 	if (currprefs.use_serial && (serstat < 0)) /* Only read status when needed */
 	    serstat=serial_readstatus();		/* and only once per frame */
@@ -329,13 +373,13 @@ static uae_u8 ReadCIAA(unsigned int addr
     case 3:
 	return ciaadrb;
     case 4:
-	return ciaata & 0xff;
+	return (ciaata - ciaata_passed) & 0xff;
     case 5:
-	return ciaata >> 8;
+	return (ciaata - ciaata_passed) >> 8;
     case 6:
-	return ciaatb & 0xff;
+	return (ciaatb - ciaatb_passed) & 0xff;
     case 7:
-	return ciaatb >> 8;
+	return (ciaatb - ciaatb_passed) >> 8;
     case 8:
 	if (ciaatlatch) {
 	    ciaatlatch = 0;
@@ -364,11 +408,13 @@ static uae_u8 ReadCIAA(unsigned int addr
     return 0;
 }
 
-static uae_u8 ReadCIAB(unsigned int addr)
+static uae_u8 ReadCIAB (unsigned int addr)
 {
     unsigned int tmp;
 
-    switch(addr & 0xf) {
+    compute_passed_time ();
+
+    switch (addr & 0xf) {
     case 0:
 	if (currprefs.use_serial && serstat < 0) /* Only read status when needed */
 	    serstat=serial_readstatus();	 /* and only once per frame      */
@@ -382,13 +428,13 @@ static uae_u8 ReadCIAB(unsigned int addr
     case 3:
 	return ciabdrb;
     case 4:
-	return ciabta & 0xff;
+	return (ciabta - ciabta_passed) & 0xff;
     case 5:
-	return ciabta >> 8;
+	return (ciabta - ciabta_passed) >> 8;
     case 6:
-	return ciabtb & 0xff;
+	return (ciabtb - ciabtb_passed) & 0xff;
     case 7:
-	return ciabtb >> 8;
+	return (ciabtb - ciabtb_passed) >> 8;
     case 8:
 	if (ciabtlatch) {
 	    ciabtlatch = 0;
@@ -417,20 +463,29 @@ static uae_u8 ReadCIAB(unsigned int addr
     return 0;
 }
 
-static void WriteCIAA(uae_u16 addr,uae_u8 val)
+static void WriteCIAA (uae_u16 addr,uae_u8 val)
 {
     int oldled, oldovl;
-    switch(addr & 0xf) {
+    switch (addr & 0xf) {
     case 0:
 	oldovl = ciaapra & 1;
 	oldled = ciaapra & 2;
-	ciaapra = (ciaapra & ~0x3) | (val & 0x3); LED(ciaapra & 0x2);
+	ciaapra = (ciaapra & ~0x3) | (val & 0x3);
+	LED(ciaapra & 0x2);
 	gui_ledstate &= ~1;
 	gui_ledstate |= ((~ciaapra & 2) >> 1);
+	gui_data.powerled = ((~ciaapra & 2) >> 1);
 	if ((ciaapra & 2) != oldled)
 	    gui_led (0, !(ciaapra & 2));
 	if ((ciaapra & 1) != oldovl) {
-	    map_banks(oldovl || ersatzkickfile ? &chipmem_bank : &kickmem_bank, 0, 32);
+	    int i = (allocated_chipmem>>16) > 32 ? allocated_chipmem >> 16 : 32;
+	    
+	    if (oldovl || ersatzkickfile) {
+		map_banks (&chipmem_bank, 0, i, allocated_chipmem);
+	    } else {
+		/* Is it OK to do this for more than 2M of chip? */
+		map_banks (&kickmem_bank, 0, i, 0x80000);
+	    }
 	}
 	break;
     case 1:
@@ -473,12 +528,12 @@ static void WriteCIAA(uae_u16 addr,uae_u
     case 3:
 	ciaadrb = val; break;
     case 4:
-	CIA_update();
+	CIA_update ();
 	ciaala = (ciaala & 0xff00) | val;
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 5:
-	CIA_update();
+	CIA_update ();
 	ciaala = (ciaala & 0xff) | (val << 8);
 	if ((ciaacra & 1) == 0)
 	    ciaata = ciaala;
@@ -486,15 +541,15 @@ static void WriteCIAA(uae_u16 addr,uae_u
 	    ciaata = ciaala;
 	    ciaacra |= 1;
 	}
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 6:
-	CIA_update();
+	CIA_update ();
 	ciaalb = (ciaalb & 0xff00) | val;
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 7:
-	CIA_update();
+	CIA_update ();
 	ciaalb = (ciaalb & 0xff) | (val << 8);
 	if ((ciaacrb & 1) == 0)
 	    ciaatb = ciaalb;
@@ -502,7 +557,7 @@ static void WriteCIAA(uae_u16 addr,uae_u
 	    ciaatb = ciaalb;
 	    ciaacrb |= 1;
 	}
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 8:
 	if (ciaacrb & 0x80) {
@@ -533,7 +588,7 @@ static void WriteCIAA(uae_u16 addr,uae_u
     case 13:
 	setclr(&ciaaimask,val); break; /* ??? call RethinkICR() ? */
     case 14:
-	CIA_update();
+	CIA_update ();
 	ciaacra = val;
 	if (ciaacra & 0x10) {
 	    ciaacra &= ~0x10;
@@ -542,24 +597,24 @@ static void WriteCIAA(uae_u16 addr,uae_u
 	if (ciaacra & 0x40) {
 	    kback = 1;
 	}
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 15:
-	CIA_update();
+	CIA_update ();
 	ciaacrb = val;
 	if (ciaacrb & 0x10) {
 	    ciaacrb &= ~0x10;
 	    ciaatb = ciaalb;
 	}
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     }
 }
 
-static void WriteCIAB(uae_u16 addr,uae_u8 val)
+static void WriteCIAB (uae_u16 addr,uae_u8 val)
 {
     int oldval;
-    switch(addr & 0xf) {
+    switch (addr & 0xf) {
     case 0:
 	if (currprefs.use_serial) {
 	    oldval = ciabpra;
@@ -574,12 +629,12 @@ static void WriteCIAB(uae_u16 addr,uae_u
     case 3:
 	ciabdrb = val; break;
     case 4:
-	CIA_update();
+	CIA_update ();
 	ciabla = (ciabla & 0xff00) | val;
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 5:
-	CIA_update();
+	CIA_update ();
 	ciabla = (ciabla & 0xff) | (val << 8);
 	if ((ciabcra & 1) == 0)
 	    ciabta = ciabla;
@@ -587,15 +642,15 @@ static void WriteCIAB(uae_u16 addr,uae_u
 	    ciabta = ciabla;
 	    ciabcra |= 1;
 	}
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 6:
-	CIA_update();
+	CIA_update ();
 	ciablb = (ciablb & 0xff00) | val;
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 7:
-	CIA_update();
+	CIA_update ();
 	ciablb = (ciablb & 0xff) | (val << 8);
 	if ((ciabcrb & 1) == 0)
 	    ciabtb = ciablb;
@@ -603,7 +658,7 @@ static void WriteCIAB(uae_u16 addr,uae_u
 	    ciabtb = ciablb;
 	    ciabcrb |= 1;
 	}
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 8:
 	if (ciabcrb & 0x80) {
@@ -636,48 +691,60 @@ static void WriteCIAB(uae_u16 addr,uae_u
 	setclr(&ciabimask,val);
 	break;
     case 14:
-	CIA_update();
+	CIA_update ();
 	ciabcra = val;
 	if (ciabcra & 0x10) {
 	    ciabcra &= ~0x10;
 	    ciabta = ciabla;
 	}
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     case 15:
-	CIA_update();
+	CIA_update ();
 	ciabcrb = val;
 	if (ciabcrb & 0x10) {
 	    ciabcrb &= ~0x10;
 	    ciabtb = ciablb;
 	}
-	CIA_calctimers();
+	CIA_calctimers ();
 	break;
     }
 }
 
-void CIA_reset(void)
+void CIA_reset (void)
 {
     kback = 1;
     kbstate = 0;
 
-    ciaatlatch = ciabtlatch = 0;
-    ciaapra = 3;
-    ciaatod = ciabtod = 0; ciaatodon = ciabtodon = 0;
-    ciaaicr = ciabicr = ciaaimask = ciabimask = 0;
-    ciaacra = ciaacrb = ciabcra = ciabcrb = 0x4; /* outmode = toggle; */
-    ciaala = ciaalb = ciabla = ciablb = ciaata = ciaatb = ciabta = ciabtb = 0xFFFF;
+    if (!savestate_state) {
+	ciaatlatch = ciabtlatch = 0;
+	ciaapra = 3;
+	ciaatod = ciabtod = 0; ciaatodon = ciabtodon = 0;
+	ciaaicr = ciabicr = ciaaimask = ciabimask = 0;
+	ciaacra = ciaacrb = ciabcra = ciabcrb = 0x4; /* outmode = toggle; */
+	ciaala = ciaalb = ciabla = ciablb = ciaata = ciaatb = ciabta = ciabtb = 0xFFFF;
+	ciabpra = 0x8C;
+    }
     div10 = 0;
-    lastdiv10 = 0;
-    CIA_calctimers();
-    ciabpra = 0x8C;
+    CIA_calctimers ();
     if (! ersatzkickfile)
-	map_banks(&kickmem_bank, 0, 32);
+	map_banks (&kickmem_bank, 0, 32, 0x80000);
 
-    if (currprefs.use_serial) serial_dtr_off(); /* Drop DTR at reset */
+    if (currprefs.use_serial && !savestate_state) 
+	serial_dtr_off (); /* Drop DTR at reset */
+
+    if (savestate_state) {
+	/* Reset oldovl and oldled */
+	uae_u8 v = ReadCIAA (0);
+	WriteCIAA (0,3);
+	WriteCIAA (0,0);
+	WriteCIAA (0,v);
+	/* select drives */
+	DISK_select (ciabprb);
+    }
 }
 
-void dumpcia(void)
+void dumpcia (void)
 {
     printf("A: CRA: %02x, CRB: %02x, IMASK: %02x, TOD: %08lx %7s TA: %04lx, TB: %04lx\n",
 	   (int)ciaacra, (int)ciaacrb, (int)ciaaimask, ciaatod,
@@ -699,21 +766,24 @@ static void cia_bput (uaecptr, uae_u32)
 addrbank cia_bank = {
     cia_lget, cia_wget, cia_bget,
     cia_lput, cia_wput, cia_bput,
-    default_xlate, default_check
+    default_xlate, default_check, NULL
 };
 
 uae_u32 REGPARAM2 cia_lget (uaecptr addr)
 {
-    return cia_bget(addr+3);
+    special_mem |= S_READ;
+    return cia_bget (addr + 3);
 }
 
 uae_u32 REGPARAM2 cia_wget (uaecptr addr)
 {
-    return cia_bget(addr+1);
+    special_mem |= S_READ;
+    return cia_bget (addr + 1);
 }
 
 uae_u32 REGPARAM2 cia_bget (uaecptr addr)
 {
+    special_mem |= S_READ;
     if ((addr & 0x3001) == 0x2001)
 	return ReadCIAA((addr & 0xF00) >> 8);
     if ((addr & 0x3001) == 0x1000)
@@ -723,20 +793,23 @@ uae_u32 REGPARAM2 cia_bget (uaecptr addr
 
 void REGPARAM2 cia_lput (uaecptr addr, uae_u32 value)
 {
-    cia_bput(addr+3,value); /* FIXME ? */
+    special_mem |= S_WRITE;
+    cia_bput (addr + 3, value); /* FIXME ? */
 }
 
 void REGPARAM2 cia_wput (uaecptr addr, uae_u32 value)
 {
-    cia_bput(addr+1,value);
+    special_mem |= S_WRITE;
+    cia_bput (addr + 1, value);
 }
 
 void REGPARAM2 cia_bput (uaecptr addr, uae_u32 value)
 {
+    special_mem |= S_WRITE;
     if ((addr & 0x3001) == 0x2001)
-	WriteCIAA((addr & 0xF00) >> 8,value);
+	WriteCIAA ((addr & 0xF00) >> 8, value);
     if ((addr & 0x3001) == 0x1000)
-	WriteCIAB((addr & 0xF00) >> 8,value);
+	WriteCIAB ((addr & 0xF00) >> 8, value);
 }
 
 /* battclock memory access */
@@ -751,24 +824,29 @@ static void clock_bput (uaecptr, uae_u32
 addrbank clock_bank = {
     clock_lget, clock_wget, clock_bget,
     clock_lput, clock_wput, clock_bput,
-    default_xlate, default_check
+    default_xlate, default_check, NULL
 };
 
 uae_u32 REGPARAM2 clock_lget (uaecptr addr)
 {
-    return clock_bget(addr+3);
+    special_mem |= S_READ;
+    return clock_bget (addr + 3);
 }
 
 uae_u32 REGPARAM2 clock_wget (uaecptr addr)
 {
-    return clock_bget(addr+1);
+    special_mem |= S_READ;
+    return clock_bget (addr + 1);
 }
 
 uae_u32 REGPARAM2 clock_bget (uaecptr addr)
 {
-    time_t t=time(0);
+    time_t t = time(0);
     struct tm *ct;
-    ct=localtime(&t);
+
+    ct = localtime (&t);
+    special_mem |= S_READ;
+
     switch (addr & 0x3f) {
     case 0x03: return ct->tm_sec % 10;
     case 0x07: return ct->tm_sec / 10;
@@ -793,19 +871,164 @@ uae_u32 REGPARAM2 clock_bget (uaecptr ad
 
 void REGPARAM2 clock_lput (uaecptr addr, uae_u32 value)
 {
+    special_mem |= S_WRITE;
     /* No way */
 }
 
 void REGPARAM2 clock_wput (uaecptr addr, uae_u32 value)
 {
+    special_mem |= S_WRITE;
     /* No way */
 }
 
 void REGPARAM2 clock_bput (uaecptr addr, uae_u32 value)
 {
+    special_mem |= S_WRITE;
     switch (addr & 0x3f) {
-    case 0x37: clock_control_d=value; break;
-    case 0x3b: clock_control_e=value; break;
-    case 0x3f: clock_control_f=value; break;
+    case 0x37: clock_control_d = value; break;
+    case 0x3b: clock_control_e = value; break;
+    case 0x3f: clock_control_f = value; break;
+    }
+}
+
+/* CIA-A and CIA-B save/restore code */
+
+uae_u8 *restore_cia (int num, uae_u8 *src)
+{
+    uae_u8 b;
+    uae_u16 w;
+    uae_u32 l;
+
+    /* CIA registers */
+    b = restore_u8 ();					/* 0 PRA */
+    if (num) ciabpra = b; else ciaapra = b;
+    b = restore_u8 ();					/* 1 PRB */
+    if (num) ciabprb = b; else ciaaprb = b;
+    b = restore_u8 ();					/* 2 DDRA */
+    if (num) ciabdra = b; else ciaadra = b;
+    b = restore_u8 ();					/* 3 DDRB */
+    if (num) ciabdrb = b; else ciaadrb = b;
+    w = restore_u16 ();					/* 4 TA */
+    if (num) ciabta = w; else ciaata = w;
+    w = restore_u16 ();					/* 6 TB */
+    if (num) ciabtb = w; else ciaatb = w;
+    l = restore_u8 ();					/* 8/9/A TOD */
+    l |= restore_u8 () << 8;
+    l |= restore_u8 () << 16;
+    if (num) ciabtod = l; else ciaatod = l;
+    restore_u8 ();						/* B unused */
+    b = restore_u8 ();					/* C SDR */
+    if (num) ciabsdr = b; else ciaasdr = b;
+    b = restore_u8 ();					/* D ICR INFORMATION (not mask!) */
+    if (num) ciabicr = b; else ciaaicr = b;
+    b = restore_u8 ();					/* E CRA */
+    if (num) ciabcra = b; else ciaacra = b;
+    b = restore_u8 ();					/* F CRB */
+    if (num) ciabcrb = b; else ciaacrb = b;
+
+/* CIA internal data */
+
+    b = restore_u8 ();					/* ICR MASK */
+    if (num) ciabimask = b; else ciaaimask = b;
+    w = restore_u8 ();					/* timer A latch */
+    w |= restore_u8 () << 8;
+    if (num) ciabla = w; else ciaala = b;
+    w = restore_u8 ();					/* timer B latch */
+    w |= restore_u8 () << 8;
+    if (num) ciablb = w; else ciaalb = w;
+    w = restore_u8 ();					/* TOD latched value */
+    w |= restore_u8 () << 8;
+    w |= restore_u8 () << 16;
+    if (num) ciabtol = w; else ciaatol = w;
+    l = restore_u8 ();					/* alarm */
+    l |= restore_u8 () << 8;
+    l |= restore_u8 () << 16;
+    if (num) ciabalarm = l; else ciaaalarm = l;
+    b = restore_u8 ();
+    if (num) ciabtlatch = b & 1; else ciaatlatch = b & 1;	/* is TOD latched? */
+    if (num) ciabtodon = b & 2; else ciaatodon = b & 2;		/* is TOD stopped? */
+    if (num) {
+	div10 = CYCLE_UNIT * restore_u8 ();
+    }
+    return src;
+}
+
+uae_u8 *save_cia (int num, int *len)
+{
+    uae_u8 *dstbak,*dst, b;
+    uae_u16 t;
+
+    dstbak = dst = malloc (16 + 12 + 1);
+
+    compute_passed_time ();
+
+    /* CIA registers */
+
+    b = num ? ciabpra : ciaapra;				/* 0 PRA */
+    save_u8 (b);
+    b = num ? ciabprb : ciaaprb;				/* 1 PRB */
+    save_u8 (b);
+    b = num ? ciabdra : ciaadra;				/* 2 DDRA */
+    save_u8 (b); 
+    b = num ? ciabdrb : ciaadrb;				/* 3 DDRB */
+    save_u8 (b);
+    t = (num ? ciabta - ciabta_passed : ciaata - ciaata_passed);/* 4 TA */
+    save_u16 (t);
+    t = (num ? ciabtb - ciabtb_passed : ciaatb - ciaatb_passed);/* 8 TB */
+    save_u16 (t);
+    b = (num ? ciabtod : ciaatod);			/* 8 TODL */
+    save_u8 (b);
+    b = (num ? ciabtod >> 8 : ciaatod >> 8);		/* 9 TODM */
+    save_u8 (b);
+    b = (num ? ciabtod >> 16 : ciaatod >> 16);		/* A TODH */
+    save_u8 (b);
+    save_u8 (0);						/* B unused */
+    b = num ? ciabsdr : ciaasdr;				/* C SDR */
+    save_u8 (b);
+    b = num ? ciabicr : ciaaicr;				/* D ICR INFORMATION (not mask!) */
+    save_u8 (b);
+    b = num ? ciabcra : ciaacra;				/* E CRA */
+    save_u8 (b);
+    b = num ? ciabcrb : ciaacrb;				/* F CRB */
+    save_u8 (b);
+
+    /* CIA internal data */
+
+    save_u8 (num ? ciabimask : ciaaimask);			/* ICR */
+    b = (num ? ciabla : ciaala);			/* timer A latch LO */
+    save_u8 (b);
+    b = (num ? ciabla >> 8 : ciaala >> 8);		/* timer A latch HI */
+    save_u8 (b);
+    b = (num ? ciablb : ciaalb);			/* timer B latch LO */
+    save_u8 (b);
+    b = (num ? ciablb >> 8 : ciaalb >> 8);		/* timer B latch HI */
+    save_u8 (b);
+    b = (num ? ciabtol : ciaatol);			/* latched TOD LO */
+    save_u8 (b);
+    b = (num ? ciabtol >> 8 : ciaatol >> 8);		/* latched TOD MED */
+    save_u8 (b);
+    b = (num ? ciabtol >> 16 : ciaatol >> 16);		/* latched TOD HI */
+    save_u8 (b);
+    b = (num ? ciabalarm : ciaaalarm);			/* alarm LO */
+    save_u8 (b);
+    b = (num ? ciabalarm >> 8 : ciaaalarm >>8 );	/* alarm MED */
+    save_u8 (b);
+    b = (num ? ciabalarm >> 16 : ciaaalarm >> 16);	/* alarm HI */
+    save_u8 (b);
+    b = 0;
+    if (num)
+	b |= ciabtlatch ? 1 : 0;
+    else
+	b |= ciaatlatch ? 1 : 0; /* is TOD latched? */
+    if (num)
+	b |= ciabtodon ? 2 : 0;
+    else
+	b |= ciaatodon ? 2 : 0;   /* TOD stopped? */
+    save_u8 (b);
+    if (num) {
+	/* Save extra state with CIAB.  */
+	save_u8 (div10 / CYCLE_UNIT);
     }
+    *len = dst - dstbak;
+    return dstbak;
 }