STATIC_INLINE void ciaa_checkalarm (int inc)
{
if (checkalarm (ciaatod, ciaaalarm, inc)) {
ciaaicr |= 4;
RethinkICRA ();
}
}
static void CIA_update (void)
{
int icr = CIA_update_check ();
if (icr & 1)
RethinkICRA ();
if (icr & 2)
RethinkICRB ();
}
void CIA_vsync_handler(void)
{
if (ciaatodon)
ciaatod++;
ciaatod &= 0xFFFFFF;
if (ciaatod == ciaaalarm) {
ciaaicr |= 4; RethinkICRA();
}
}
void CIA_hsync_handler (void)
{
static unsigned int keytime = 0, sleepyhead = 0;
if (ciabtodon) {
ciabtod++;
ciabtod &= 0xFFFFFF;
ciab_checkalarm (1);
}
if (ciabtod == ciabalarm) {
ciabicr |= 4; RethinkICRB ();
}
/* check wether the serial port gets some data */
if (doreadser)
doreadser = SERDATS();
if (keys_available() && kback && (ciaacra & 0x40) == 0 && (++keytime & 15) == 0) {
/*
* This hack lets one possible ciaaicr cycle go by without any key
* being read, for every cycle in which a key is pulled out of the
* queue. If no hack is used, a lot of key events just get lost
* when you type fast. With a simple hack that waits for ciaasdr
* to be read before feeding it another, it will keep up until the
* queue gets about 14 characters ahead and then lose events, and
* the mouse pointer will freeze while typing is being taken in.
* With this hack, you can type 30 or 40 characters ahead with little
* or no lossage, and the mouse doesn't get stuck. The tradeoff is
* that the total slowness of typing appearing on screen is worse.
*/
if (ciaasdr_unread == 2) {
ciaasdr_unread = 0;
} else if (ciaasdr_unread == 0) {
switch (kbstate) {
case 0:
ciaasdr = (uae_s8)~0xFB; /* aaarghh... stupid compiler */
kbstate++;
break;
case 1:
kbstate++;
ciaasdr = (uae_s8)~0xFD;
break;
case 2:
ciaasdr = ~get_next_key();
ciaasdr_unread = 1; /* interlock to prevent lost keystrokes */
break;
}
ciaaicr |= 8;
RethinkICRA ();
sleepyhead = 0;
} else if (!(++sleepyhead & 15)) {
ciaasdr_unread = 0; /* give up on this key event after unread for a long time */
}
}
}
static uae_u8 ReadCIAA(unsigned int addr)
{
unsigned int tmp;
switch(addr & 0xf) {
case 0:
tmp = 0;
if ((JSEM_ISMOUSE (0, &currprefs))
|| (!JSEM_ISMOUSE (0, &currprefs) && !(joy0button & 1)))
tmp |= 0x40;
if (!(joy1button & 1))
tmp |= 0x80;
return tmp;
case 1:
return ciaaprb;
case 2:
return ciaadra;
case 3:
return ciaadrb;
case 4:
return ciaata & 0xff;
case 5:
return ciaata >> 8;
case 6:
return ciaatb & 0xff;
case 7:
return ciaatb >> 8;
case 8:
if (ciaatlatch) {
ciaatlatch = 0;
return ciaatol & 0xff;
} else
return ciaatod & 0xff;
case 9:
if (ciaatlatch)
return (ciaatol >> 8) & 0xff;
else
return (ciaatod >> 8) & 0xff;
case 10:
ciaatlatch = 1;
ciaatol = ciaatod; /* ??? only if not already latched? */
return (ciaatol >> 16) & 0xff;
case 12:
if (ciaasdr == 1) ciaasdr_unread = 2;
return ciaasdr;
case 13:
tmp = ciaaicr; ciaaicr = 0; RethinkICRA(); return tmp;
case 14:
return ciaacra;
case 15:
return ciaacrb;
}
void cia_parallelack (void)
{
ciaaicr |= 0x10;
RethinkICRA ();
}
void rethink_cias (void)
{
RethinkICRA ();
RethinkICRB ();
}
static uae_u8 ReadCIAA (unsigned int addr)
{
unsigned int tmp;
compute_passed_time ();
#ifdef CIA_DEBUG
write_log("R_CIAA: %02.2X %08.8X\n", addr, m68k_getpc());
#endif
switch (addr & 0xf) {
case 0:
#ifdef ACTION_REPLAY
action_replay_ciaread();
#endif
tmp = DISK_status() & 0x3c;
tmp |= handle_joystick_buttons (ciaadra);
tmp |= (ciaapra | (ciaadra ^ 3)) & 0x03;
if (ciaadra & 0x40)
tmp = (tmp & ~0x40) | (ciaapra & 0x40);
if (ciaadra & 0x80)
tmp = (tmp & ~0x80) | (ciaapra & 0x80);
#ifdef DONGLE_DEBUG
if (notinrom())
write_log ("BFE001 R %02.2X %s\n", tmp, debuginfo(0));
#endif
return tmp;
case 1:
#ifdef PARALLEL_PORT
if (isprinter () > 0) {
tmp = ciaaprb;
} else if (isprinter () < 0) {
uae_u8 v;
parallel_direct_read_data (&v);
tmp = v;
} else {
tmp = handle_parport_joystick (0, ciaaprb, ciaadrb);
}
#else
tmp = handle_parport_joystick (0, ciaaprb, ciaadrb);
#ifdef DONGLE_DEBUG
if (notinrom())
write_log ("BFE101 R %02.2X %s\n", tmp, debuginfo(0));
#endif
#endif
return tmp;
case 2:
#ifdef DONGLE_DEBUG
if (notinrom ())
write_log ("BFE201 R %02.2X %s\n", ciaadra, debuginfo(0));
#endif
return ciaadra;
case 3:
#ifdef DONGLE_DEBUG
if (notinrom ())
write_log ("BFE301 R %02.2X %s\n", ciaadrb, debuginfo(0));
#endif
return ciaadrb;
case 4:
return (uae_u8)((ciaata - ciaata_passed) & 0xff);
case 5:
return (uae_u8)((ciaata - ciaata_passed) >> 8);
case 6:
return (uae_u8)((ciaatb - ciaatb_passed) & 0xff);
case 7:
return (uae_u8)((ciaatb - ciaatb_passed) >> 8);
case 8:
if (ciaatlatch) {
ciaatlatch = 0;
return (uae_u8)ciaatol;
} else
return (uae_u8)ciaatod;
case 9:
if (ciaatlatch)
return (uae_u8)(ciaatol >> 8);
else
return (uae_u8)(ciaatod >> 8);
case 10:
ciaatlatch = 1;
ciaatol = ciaatod; /* ??? only if not already latched? */
return (uae_u8)(ciaatol >> 16);
case 12:
if (ciaasdr_unread == 1)
ciaasdr_unread = 2;
return ciaasdr;
case 13:
tmp = ciaaicr; ciaaicr = 0; RethinkICRA();
return tmp;
case 14:
return ciaacra;
case 15:
return ciaacrb;
}
static void ciaa_checkalarm (void)
{
if (ciaatod != ciaaalarm)
return;
ciaaicr |= 4; RethinkICRA();
}
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, asp = 0, bovfla = 0, bovflb = 0, bsp = 0;
div10 = ccount % DIV10;
/* CIA A timers */
if ((ciaacra & 0x21) == 0x01) {
assert ((ciaata+1) >= ciaclocks);
if ((ciaata+1) == ciaclocks) {
if ((ciaacra & 0x48) == 0x40 && ciaasdr_cnt > 0 && --ciaasdr_cnt == 0)
asp = 1;
aovfla = 1;
if ((ciaacrb & 0x61) == 0x41) {
if (ciaatb-- == 0)
aovflb = 1;
}
}
ciaata -= ciaclocks;
}
if ((ciaacrb & 0x61) == 0x01) {
assert ((ciaatb+1) >= ciaclocks);
if ((ciaatb+1) == ciaclocks) aovflb = 1;
ciaatb -= ciaclocks;
}
/* CIA B timers */
if ((ciabcra & 0x21) == 0x01) {
assert ((ciabta+1) >= ciaclocks);
if ((ciabta+1) == ciaclocks) {
if ((ciabcra & 0x48) == 0x40 && ciabsdr_cnt > 0 && --ciabsdr_cnt == 0)
bsp = 1;
bovfla = 1;
if ((ciabcrb & 0x61) == 0x41) {
if (ciabtb-- == 0)
bovflb = 1;
}
}
ciabta -= ciaclocks;
}
if ((ciabcrb & 0x61) == 0x01) {
assert ((ciabtb+1) >= ciaclocks);
if ((ciabtb+1) == ciaclocks) bovflb = 1;
ciabtb -= ciaclocks;
}
if (aovfla) {
ciaaicr |= 1; RethinkICRA();
ciaata = ciaala;
if (ciaacra & 0x8) ciaacra &= ~1;
}
if (aovflb) {
ciaaicr |= 2; RethinkICRA();
ciaatb = ciaalb;
if (ciaacrb & 0x8) ciaacrb &= ~1;
}
if (asp) {
ciaaicr |= 8; RethinkICRA();
}
if (bovfla) {
ciabicr |= 1; RethinkICRB();
ciabta = ciabla;
if (ciabcra & 0x8) ciabcra &= ~1;
}
if (bovflb) {
ciabicr |= 2; RethinkICRB();
ciabtb = ciablb;
if (ciabcrb & 0x8) ciabcrb &= ~1;
}
if (bsp) {
ciabicr |= 8; RethinkICRB();
}
}
static void CIA_update(void)
{
unsigned long int ccount = cycles - eventtab[ev_cia].oldcycles + lastdiv10;
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);
if ((ciaata+1) == ciaclocks) {
aovfla = 1;
if ((ciaacrb & 0x61) == 0x41) {
if (ciaatb-- == 0) aovflb = 1;
}
}
ciaata -= ciaclocks;
}
if ((ciaacrb & 0x61) == 0x01) {
assert((ciaatb+1) >= ciaclocks);
if ((ciaatb+1) == ciaclocks) aovflb = 1;
ciaatb -= ciaclocks;
}
/* CIA B timers */
if ((ciabcra & 0x21) == 0x01) {
assert((ciabta+1) >= ciaclocks);
if ((ciabta+1) == ciaclocks) {
bovfla = 1;
if ((ciabcrb & 0x61) == 0x41) {
if (ciabtb-- == 0) bovflb = 1;
}
}
ciabta -= ciaclocks;
}
if ((ciabcrb & 0x61) == 0x01) {
assert ((ciabtb+1) >= ciaclocks);
if ((ciabtb+1) == ciaclocks) bovflb = 1;
ciabtb -= ciaclocks;
}
if (aovfla) {
ciaaicr |= 1; RethinkICRA();
ciaata = ciaala;
if (ciaacra & 0x8) ciaacra &= ~1;
}
if (aovflb) {
ciaaicr |= 2; RethinkICRA();
ciaatb = ciaalb;
if (ciaacrb & 0x8) ciaacrb &= ~1;
}
if (bovfla) {
ciabicr |= 1; RethinkICRB();
ciabta = ciabla;
if (ciabcra & 0x8) ciabcra &= ~1;
}
if (bovflb) {
ciabicr |= 2; RethinkICRB();
ciabtb = ciablb;
if (ciabcrb & 0x8) ciabcrb &= ~1;
}
}
