pico/z80if.c

   1 #include "pico_int.h"
   2 #include "sound/sn76496.h"
   3
   4 #define Z80_MEM_SHIFT 13
   5
   6 unsigned long z80_read_map [0x10000 >> Z80_MEM_SHIFT];
   7 unsigned long z80_write_map[0x10000 >> Z80_MEM_SHIFT];
   8
   9 void MEMH_FUNC z80_map_set(unsigned long *map, int start_addr, int end_addr,
  10     void *func_or_mh, int is_func)
  11 {
  12   unsigned long addr = (unsigned long)func_or_mh;
  13   int mask = (1 << Z80_MEM_SHIFT) - 1;
  14   int i;
  15
  16   if ((start_addr & mask) != 0 || (end_addr & mask) != mask)
  17     elprintf(EL_STATUS|EL_ANOMALY, "z80_map_set: tried to map bad range: %04x-%04x",
  18       start_addr, end_addr);
  19
  20   if (addr & 1) {
  21     elprintf(EL_STATUS|EL_ANOMALY, "z80_map_set: ptr is not aligned: %08lx", addr);
  22     return;
  23   }
  24
  25   if (!is_func)
  26     addr -= (start_addr >> Z80_MEM_SHIFT) << Z80_MEM_SHIFT;
  27
  28   for (i = start_addr >> Z80_MEM_SHIFT; i <= end_addr >> Z80_MEM_SHIFT; i++) {
  29     map[i] = addr >> 1;
  30     if (is_func)
  31       map[i] |= 1 << (sizeof(addr) * 8 - 1);
  32   }
  33 }
  34
  35 #ifdef _USE_MZ80
  36
  37 // memhandlers for mz80 core
  38 unsigned char mz80_read(UINT32 a,  struct MemoryReadByte *w)  { return z80_read(a); }
  39 void mz80_write(UINT32 a, UINT8 d, struct MemoryWriteByte *w) { z80_write(d, a); }
  40
  41 // structures for mz80 core
  42 static struct MemoryReadByte mz80_mem_read[]=
  43 {
  44   {0x0000,0xffff,mz80_read},
  45   {(UINT32) -1,(UINT32) -1,NULL}
  46 };
  47 static struct MemoryWriteByte mz80_mem_write[]=
  48 {
  49   {0x0000,0xffff,mz80_write},
  50   {(UINT32) -1,(UINT32) -1,NULL}
  51 };
  52 static struct z80PortRead mz80_io_read[] ={
  53   {(UINT16) -1,(UINT16) -1,NULL}
  54 };
  55 static struct z80PortWrite mz80_io_write[]={
  56   {(UINT16) -1,(UINT16) -1,NULL}
  57 };
  58
  59 int mz80_run(int cycles)
  60 {
  61   int ticks_pre = mz80GetElapsedTicks(0);
  62   mz80exec(cycles);
  63   return mz80GetElapsedTicks(0) - ticks_pre;
  64 }
  65
  66 #endif
  67
  68 #ifdef _USE_DRZ80
  69 struct DrZ80 drZ80;
  70 #endif
  71
  72
  73 PICO_INTERNAL void z80_init(void)
  74 {
  75 #ifdef _USE_MZ80
  76   struct mz80context z80;
  77
  78   // z80
  79   mz80init();
  80   // Modify the default context
  81   mz80GetContext(&z80);
  82
  83   // point mz80 stuff
  84   z80.z80Base=Pico.zram;
  85   z80.z80MemRead=mz80_mem_read;
  86   z80.z80MemWrite=mz80_mem_write;
  87   z80.z80IoRead=mz80_io_read;
  88   z80.z80IoWrite=mz80_io_write;
  89
  90   mz80SetContext(&z80);
  91 #endif
  92 #ifdef _USE_DRZ80
  93   memset(&drZ80, 0, sizeof(drZ80));
  94   drZ80.z80_rebasePC=NULL; // unused, handled by xmap
  95   drZ80.z80_rebaseSP=NULL;
  96   drZ80.z80_read8   =(void *)z80_read_map;
  97   drZ80.z80_read16  =NULL;
  98   drZ80.z80_write8  =(void *)z80_write_map;
  99   drZ80.z80_write16 =NULL;
 100   drZ80.z80_irq_callback=NULL;
 101 #endif
 102 #ifdef _USE_CZ80
 103   memset(&CZ80, 0, sizeof(CZ80));
 104   Cz80_Init(&CZ80);
 105   Cz80_Set_ReadB(&CZ80, NULL); // unused (hacked in)
 106   Cz80_Set_WriteB(&CZ80, NULL);
 107 #endif
 108 }
 109
 110 PICO_INTERNAL void z80_reset(void)
 111 {
 112 #ifdef _USE_MZ80
 113   mz80reset();
 114 #endif
 115 #ifdef _USE_DRZ80
 116   memset(&drZ80, 0, 0x54);
 117   drZ80.Z80F  = (1<<2);  // set ZFlag
 118   drZ80.Z80F2 = (1<<2);  // set ZFlag
 119   drZ80.Z80IX = 0xFFFF << 16;
 120   drZ80.Z80IY = 0xFFFF << 16;
 121   drZ80.Z80IM = 0; // 1?
 122   drZ80.z80irqvector = 0xff0000; // RST 38h
 123   drZ80.Z80PC_BASE = drZ80.Z80PC = z80_read_map[0] << 1;
 124   // drZ80 is locked in single bank
 125   drZ80.Z80SP_BASE = ((PicoAHW & PAHW_SMS) ?
 126     z80_read_map[0xc000 >> Z80_MEM_SHIFT] : z80_read_map[0]) << 1;
 127 //  drZ80.Z80SP = drZ80.z80_rebaseSP(0x2000); // 0xf000 ?
 128 #endif
 129 #ifdef _USE_CZ80
 130   Cz80_Reset(&CZ80);
 131   Cz80_Set_Reg(&CZ80, CZ80_IX, 0xffff);
 132   Cz80_Set_Reg(&CZ80, CZ80_IY, 0xffff);
 133   Cz80_Set_Reg(&CZ80, CZ80_SP, 0x2000);
 134 #endif
 135   Pico.m.z80_fakeval = 0; // for faking when Z80 is disabled
 136 }
 137
 138 // XXX TODO: should better use universal z80 save format
 139 PICO_INTERNAL void z80_pack(unsigned char *data)
 140 {
 141 #if defined(_USE_MZ80)
 142   struct mz80context mz80;
 143   *(int *)data = 0x00005A6D; // "mZ"
 144   mz80GetContext(&mz80);
 145   memcpy(data+4, &mz80.z80clockticks, sizeof(mz80)-5*4); // don't save base&memhandlers
 146 #elif defined(_USE_DRZ80)
 147   *(int *)data = 0x015A7244; // "DrZ" v1
 148 //  drZ80.Z80PC = drZ80.z80_rebasePC(drZ80.Z80PC-drZ80.Z80PC_BASE);
 149 //  drZ80.Z80SP = drZ80.z80_rebaseSP(drZ80.Z80SP-drZ80.Z80SP_BASE);
 150   memcpy(data+4, &drZ80, 0x54);
 151 #elif defined(_USE_CZ80)
 152   *(int *)data = 0x00007a43; // "Cz"
 153   *(int *)(data+4) = Cz80_Get_Reg(&CZ80, CZ80_PC);
 154   memcpy(data+8, &CZ80, (INT32)&CZ80.BasePC - (INT32)&CZ80);
 155 #endif
 156 }
 157
 158 PICO_INTERNAL void z80_unpack(unsigned char *data)
 159 {
 160 #if defined(_USE_MZ80)
 161   if (*(int *)data == 0x00005A6D) { // "mZ" save?
 162     struct mz80context mz80;
 163     mz80GetContext(&mz80);
 164     memcpy(&mz80.z80clockticks, data+4, sizeof(mz80)-5*4);
 165     mz80SetContext(&mz80);
 166   } else {
 167     z80_reset();
 168     z80_int();
 169   }
 170 #elif defined(_USE_DRZ80)
 171   if (*(int *)data == 0x015A7244) { // "DrZ" v1 save?
 172     int pc, sp;
 173     memcpy(&drZ80, data+4, 0x54);
 174     pc = (drZ80.Z80PC - drZ80.Z80PC_BASE) & 0xffff;
 175     sp = (drZ80.Z80SP - drZ80.Z80SP_BASE) & 0xffff;
 176     // update bases
 177     drZ80.Z80PC_BASE = z80_read_map[pc >> Z80_MEM_SHIFT];
 178     if (drZ80.Z80PC & (1<<31)) {
 179       elprintf(EL_STATUS|EL_ANOMALY, "bad PC in z80 save: %04x", pc);
 180       drZ80.Z80PC_BASE = drZ80.Z80PC = z80_read_map[0];
 181     } else {
 182       drZ80.Z80PC_BASE <<= 1;
 183       drZ80.Z80PC = drZ80.Z80PC_BASE + pc;
 184     }
 185     drZ80.Z80SP_BASE = z80_read_map[sp >> Z80_MEM_SHIFT];
 186     if (drZ80.Z80SP & (1<<31)) {
 187       elprintf(EL_STATUS|EL_ANOMALY, "bad SP in z80 save: %04x", sp);
 188       drZ80.Z80SP_BASE = z80_read_map[0];
 189       drZ80.Z80SP = drZ80.Z80SP_BASE + (1 << Z80_MEM_SHIFT);
 190     } else {
 191       drZ80.Z80SP_BASE <<= 1;
 192       drZ80.Z80SP = drZ80.Z80SP_BASE + sp;
 193     }
 194   } else {
 195     z80_reset();
 196     drZ80.Z80IM = 1;
 197     z80_int(); // try to goto int handler, maybe we won't execute trash there?
 198   }
 199 #elif defined(_USE_CZ80)
 200   if (*(int *)data == 0x00007a43) { // "Cz" save?
 201     memcpy(&CZ80, data+8, (INT32)&CZ80.BasePC - (INT32)&CZ80);
 202     Cz80_Set_Reg(&CZ80, CZ80_PC, *(int *)(data+4));
 203   } else {
 204     z80_reset();
 205     z80_int();
 206   }
 207 #endif
 208 }
 209
 210 PICO_INTERNAL void z80_exit(void)
 211 {
 212 #if defined(_USE_MZ80)
 213   mz80shutdown();
 214 #endif
 215 }
 216
 217 PICO_INTERNAL void z80_debug(char *dstr)
 218 {
 219 #if defined(_USE_DRZ80)
 220   sprintf(dstr, "Z80 state: PC: %04x SP: %04x\n", drZ80.Z80PC-drZ80.Z80PC_BASE, drZ80.Z80SP-drZ80.Z80SP_BASE);
 221 #elif defined(_USE_CZ80)
 222   sprintf(dstr, "Z80 state: PC: %04x SP: %04x\n", CZ80.PC - CZ80.BasePC, CZ80.SP.W);
 223 #endif
 224 }