Shamusworld >> Repos - virtualjaguar/blob - src/jaguar.cpp

   1 //
   2 // JAGUAR.CPP
   3 //
   4 // Originally by David Raingeard (Cal2)
   5 // GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Carwin Jones (BeOS)
   6 // Cleanups and endian wrongness amelioration by James L. Hammons
   7 // Note: Endian wrongness probably stems from the MAME origins of this emu and
   8 //       the braindead way in which MAME handles memory. :-)
   9 //
  10
  11 #include "jaguar.h"
  12 #include "video.h"
  13 #include "settings.h"
  14 //#include "m68kdasmAG.h"
  15
  16 #define CPU_DEBUG
  17 //Do this in makefile??? Yes! Could, but it's easier to define here...
  18 //#define LOG_UNMAPPED_MEMORY_ACCESSES
  19 //#define ABORT_ON_UNMAPPED_MEMORY_ACCESS
  20 #define CPU_DEBUG_MEMORY
  21
  22 // Private function prototypes
  23
  24 unsigned jaguar_unknown_readbyte(unsigned address, uint32 who = UNKNOWN);
  25 unsigned jaguar_unknown_readword(unsigned address, uint32 who = UNKNOWN);
  26 void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32 who = UNKNOWN);
  27 void jaguar_unknown_writeword(unsigned address, unsigned data, uint32 who = UNKNOWN);
  28 void M68K_show_context(void);
  29
  30 // External variables
  31
  32 //extern bool hardwareTypeNTSC;                                         // Set to false for PAL
  33 #ifdef CPU_DEBUG_MEMORY
  34 extern bool startMemLog;                                                        // Set by "e" key
  35 extern int effect_start;
  36 extern int effect_start2, effect_start3, effect_start4, effect_start5, effect_start6;
  37 #endif
  38
  39 // Memory debugging identifiers
  40
  41 char * whoName[9] =
  42         { "Unknown", "Jaguar", "DSP", "GPU", "TOM", "JERRY", "M68K", "Blitter", "OP" };
  43
  44 uint32 jaguar_active_memory_dumps = 0;
  45
  46 uint32 jaguar_mainRom_crc32, jaguarRomSize, jaguarRunAddress;
  47
  48 /*static*/ uint8 * jaguar_mainRam = NULL;
  49 /*static*/ uint8 * jaguar_bootRom = NULL;
  50 /*static*/ uint8 * jaguar_mainRom = NULL;
  51
  52 #ifdef CPU_DEBUG_MEMORY
  53 uint8 writeMemMax[0x400000], writeMemMin[0x400000];
  54 uint8 readMem[0x400000];
  55 uint32 returnAddr[4000], raPtr = 0xFFFFFFFF;
  56 #endif
  57
  58 uint32 pcQueue[0x400];
  59 uint32 pcQPtr = 0;
  60
  61 //
  62 // Callback function to detect illegal instructions
  63 //
  64 //void GPUDumpDisassembly(void);
  65 //void GPUDumpRegisters(void);
  66 void M68KInstructionHook(void)
  67 {
  68         uint32 m68kPC = m68k_get_reg(NULL, M68K_REG_PC);
  69
  70 // For tracebacks...
  71 // Ideally, we'd save all the registers as well...
  72         pcQueue[pcQPtr++] = m68kPC;
  73         pcQPtr &= 0x3FF;
  74
  75         if (m68kPC & 0x01)              // Oops! We're fetching an odd address!
  76         {
  77                 WriteLog("M68K: Attempted to execute from an odd adress!\n\nBacktrace:\n\n");
  78
  79                 static char buffer[2048];
  80                 for(int i=0; i<0x400; i++)
  81                 {
  82                         m68k_disassemble(buffer, pcQueue[(pcQPtr + i) & 0x3FF], M68K_CPU_TYPE_68000);
  83                         WriteLog("\t%08X: %s\n", pcQueue[(pcQPtr + i) & 0x3FF], buffer);
  84                 }
  85                 WriteLog("\n");
  86
  87                 uint32 topOfStack = m68k_get_reg(NULL, M68K_REG_A7);
  88                 WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack));
  89                 for(int i=0; i<10; i++)
  90                         WriteLog("%06X: %08X\n", topOfStack - (i * 4), JaguarReadLong(topOfStack - (i * 4)));
  91                 WriteLog("Jaguar: VBL interrupt is %s\n", ((tom_irq_enabled(IRQ_VBLANK)) && (jaguar_interrupt_handler_is_valid(64))) ? "enabled" : "disabled");
  92                 M68K_show_context();
  93                 log_done();
  94                 exit(0);
  95         }
  96
  97 /*      if (m68kPC >= 0x807EC4 && m68kPC <= 0x807EDB)
  98         {
  99                 static char buffer[2048];
 100                 m68k_disassemble(buffer, m68kPC, M68K_CPU_TYPE_68000);
 101                 WriteLog("%08X: %s", m68kPC, buffer);
 102                 WriteLog("\t\tA0=%08X, A1=%08X, D0=%08X, D1=%08X\n",
 103                         m68k_get_reg(NULL, M68K_REG_A0), m68k_get_reg(NULL, M68K_REG_A1),
 104                         m68k_get_reg(NULL, M68K_REG_D0), m68k_get_reg(NULL, M68K_REG_D1));
 105         }//*/
 106 /*      if (m68kPC == 0x8D0E48 && effect_start5)
 107         {
 108                 WriteLog("\nM68K: At collision detection code. Exiting!\n\n");
 109                 GPUDumpRegisters();
 110                 GPUDumpDisassembly();
 111                 log_done();
 112                 exit(0);
 113         }//*/
 114 /*      uint16 opcode = JaguarReadWord(m68kPC);
 115         if (opcode == 0x4E75)   // RTS
 116         {
 117                 if (startMemLog)
 118 //                      WriteLog("Jaguar: Returning from subroutine to %08X\n", JaguarReadLong(m68k_get_reg(NULL, M68K_REG_A7)));
 119                 {
 120                         uint32 addr = JaguarReadLong(m68k_get_reg(NULL, M68K_REG_A7));
 121                         bool found = false;
 122                         if (raPtr != 0xFFFFFFFF)
 123                         {
 124                                 for(uint32 i=0; i<=raPtr; i++)
 125                                 {
 126                                         if (returnAddr[i] == addr)
 127                                         {
 128                                                 found = true;
 129                                                 break;
 130                                         }
 131                                 }
 132                         }
 133
 134                         if (!found)
 135                                 returnAddr[++raPtr] = addr;
 136                 }
 137         }//*/
 138
 139 /*      static char buffer[2048];
 140         m68k_disassemble(buffer, m68kPC, M68K_CPU_TYPE_68000);
 141         WriteLog("%08X: %s \t\tD0=%08X, A0=%08X\n", m68kPC, buffer, m68k_get_reg(NULL, M68K_REG_D0), m68k_get_reg(NULL, M68K_REG_A0));//*/
 142
 143 /*      if (m68kPC == 0x803F16)
 144         {
 145                 WriteLog("M68K: Registers found at $803F16:\n");
 146                 WriteLog("\t68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC));
 147                 for(int i=M68K_REG_D0; i<=M68K_REG_D7; i++)
 148                         WriteLog("\tD%i = %08X\n", i-M68K_REG_D0, m68k_get_reg(NULL, (m68k_register_t)i));
 149                 WriteLog("\n");
 150                 for(int i=M68K_REG_A0; i<=M68K_REG_A7; i++)
 151                         WriteLog("\tA%i = %08X\n", i-M68K_REG_A0, m68k_get_reg(NULL, (m68k_register_t)i));
 152         }*/
 153
 154         if (!m68k_is_valid_instruction(m68k_read_memory_16(m68kPC), M68K_CPU_TYPE_68000))
 155         {
 156                 WriteLog("\nM68K encountered an illegal instruction at %08X!!!\n\nAborting!\n", m68kPC);
 157                 uint32 topOfStack = m68k_get_reg(NULL, M68K_REG_A7);
 158                 WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack));
 159                 for(int i=0; i<10; i++)
 160                         WriteLog("%06X: %08X\n", topOfStack - (i * 4), JaguarReadLong(topOfStack - (i * 4)));
 161                 WriteLog("Jaguar: VBL interrupt is %s\n", ((tom_irq_enabled(IRQ_VBLANK)) && (jaguar_interrupt_handler_is_valid(64))) ? "enabled" : "disabled");
 162                 M68K_show_context();
 163                 log_done();
 164                 exit(0);
 165         }//*/
 166 }
 167
 168 //
 169 // Musashi 68000 read/write/IRQ functions
 170 //
 171
 172 int irq_ack_handler(int level)
 173 {
 174         int vector = M68K_INT_ACK_AUTOVECTOR;
 175
 176         // The GPU/DSP/etc are probably *not* issuing an NMI, but it seems to work OK...
 177
 178         if (level == 7)
 179         {
 180                 m68k_set_irq(0);                                                // Clear the IRQ...
 181                 vector = 64;                                                    // Set user interrupt #0
 182         }
 183
 184         return vector;
 185 }
 186
 187 unsigned int m68k_read_memory_8(unsigned int address)
 188 {
 189 #ifdef CPU_DEBUG_MEMORY
 190         if ((address >= 0x000000) && (address <= 0x3FFFFF))
 191         {
 192                 if (startMemLog)
 193                         readMem[address] = 1;
 194         }
 195 #endif
 196 //WriteLog("[RM8] Addr: %08X\n", address);
 197         unsigned int retVal = 0;
 198
 199         if ((address >= 0x000000) && (address <= 0x3FFFFF))
 200                 retVal = jaguar_mainRam[address];
 201         else if ((address >= 0x800000) && (address <= 0xDFFFFF))
 202                 retVal = jaguar_mainRom[address - 0x800000];
 203         else if ((address >= 0xE00000) && (address <= 0xE3FFFF))
 204                 retVal = jaguar_bootRom[address - 0xE00000];
 205         else if ((address >= 0xDFFF00) && (address <= 0xDFFFFF))
 206                 retVal = CDROMReadByte(address);
 207         else if ((address >= 0xF00000) && (address <= 0xF0FFFF))
 208                 retVal = TOMReadByte(address, M68K);
 209         else if ((address >= 0xF10000) && (address <= 0xF1FFFF))
 210                 retVal = JERRYReadByte(address, M68K);
 211         else
 212                 retVal = jaguar_unknown_readbyte(address, M68K);
 213
 214     return retVal;
 215 }
 216
 217 void gpu_dump_disassembly(void);
 218 void gpu_dump_registers(void);
 219
 220 unsigned int m68k_read_memory_16(unsigned int address)
 221 {
 222 #ifdef CPU_DEBUG_MEMORY
 223 /*      if ((address >= 0x000000) && (address <= 0x3FFFFE))
 224         {
 225                 if (startMemLog)
 226                         readMem[address] = 1, readMem[address + 1] = 1;
 227         }//*/
 228 /*      if (effect_start && (address >= 0x8064FC && address <= 0x806501))
 229         {
 230                 return 0x4E71;  // NOP
 231         }
 232         if (effect_start2 && (address >= 0x806502 && address <= 0x806507))
 233         {
 234                 return 0x4E71;  // NOP
 235         }
 236         if (effect_start3 && (address >= 0x806512 && address <= 0x806517))
 237         {
 238                 return 0x4E71;  // NOP
 239         }
 240         if (effect_start4 && (address >= 0x806524 && address <= 0x806527))
 241         {
 242                 return 0x4E71;  // NOP
 243         }
 244         if (effect_start5 && (address >= 0x80653E && address <= 0x806543)) //Collision detection!
 245         {
 246                 return 0x4E71;  // NOP
 247         }
 248         if (effect_start6 && (address >= 0x806544 && address <= 0x806547))
 249         {
 250                 return 0x4E71;  // NOP
 251         }//*/
 252 #endif
 253 //WriteLog("[RM16] Addr: %08X\n", address);
 254 /*if (m68k_get_reg(NULL, M68K_REG_PC) == 0x00005FBA)
 255 //      for(int i=0; i<10000; i++)
 256         WriteLog("[M68K] In routine #6!\n");//*/
 257 //if (m68k_get_reg(NULL, M68K_REG_PC) == 0x00006696) // GPU Program #4
 258 //if (m68k_get_reg(NULL, M68K_REG_PC) == 0x00005B3C)    // GPU Program #2
 259 /*if (m68k_get_reg(NULL, M68K_REG_PC) == 0x00005BA8)    // GPU Program #3
 260 {
 261         WriteLog("[M68K] About to run GPU! (Addr:%08X, data:%04X)\n", address, TOMReadWord(address));
 262         gpu_dump_registers();
 263         gpu_dump_disassembly();
 264 //      for(int i=0; i<10000; i++)
 265 //              WriteLog("[M68K] About to run GPU!\n");
 266 }//*/
 267 //WriteLog("[WM8  PC=%08X] Addr: %08X, val: %02X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);
 268 /*if (m68k_get_reg(NULL, M68K_REG_PC) >= 0x00006696 && m68k_get_reg(NULL, M68K_REG_PC) <= 0x000066A8)
 269 {
 270         if (address == 0x000066A0)
 271         {
 272                 gpu_dump_registers();
 273                 gpu_dump_disassembly();
 274         }
 275         for(int i=0; i<10000; i++)
 276                 WriteLog("[M68K] About to run GPU! (Addr:%08X, data:%04X)\n", address, TOMReadWord(address));
 277 }//*/
 278     unsigned int retVal = 0;
 279
 280         if ((address >= 0x000000) && (address <= 0x3FFFFE))
 281                 retVal = (jaguar_mainRam[address] << 8) | jaguar_mainRam[address+1];
 282         else if ((address >= 0x800000) && (address <= 0xDFFFFE))
 283                 retVal = (jaguar_mainRom[address - 0x800000] << 8) | jaguar_mainRom[address - 0x800000 + 1];
 284         else if ((address >= 0xE00000) && (address <= 0xE3FFFE))
 285                 retVal = (jaguar_bootRom[address - 0xE00000] << 8) | jaguar_bootRom[address - 0xE00000 + 1];
 286         else if ((address >= 0xDFFF00) && (address <= 0xDFFFFE))
 287                 retVal = CDROMReadWord(address, M68K);
 288         else if ((address >= 0xF00000) && (address <= 0xF0FFFE))
 289                 retVal = TOMReadWord(address, M68K);
 290         else if ((address >= 0xF10000) && (address <= 0xF1FFFE))
 291                 retVal = JERRYReadWord(address, M68K);
 292         else
 293                 retVal = jaguar_unknown_readword(address, M68K);
 294
 295     return retVal;
 296 }
 297
 298 unsigned int m68k_read_memory_32(unsigned int address)
 299 {
 300 //WriteLog("--> [RM32]\n");
 301     return (m68k_read_memory_16(address) << 16) | m68k_read_memory_16(address + 2);
 302 }
 303
 304 void m68k_write_memory_8(unsigned int address, unsigned int value)
 305 {
 306 #ifdef CPU_DEBUG_MEMORY
 307         if ((address >= 0x000000) && (address <= 0x3FFFFF))
 308         {
 309                 if (startMemLog)
 310                 {
 311                         if (value > writeMemMax[address])
 312                                 writeMemMax[address] = value;
 313                         if (value < writeMemMin[address])
 314                                 writeMemMin[address] = value;
 315                 }
 316         }
 317 #endif
 318 //if ((address >= 0x1FF020 && address <= 0x1FF03F) || (address >= 0x1FF820 && address <= 0x1FF83F))
 319 //      WriteLog("M68K: Writing %02X at %08X\n", value, address);
 320 //WriteLog("[WM8  PC=%08X] Addr: %08X, val: %02X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);
 321         if ((address >= 0x000000) && (address <= 0x3FFFFF))
 322                 jaguar_mainRam[address] = value;
 323         else if ((address >= 0xDFFF00) && (address <= 0xDFFFFF))
 324                 CDROMWriteByte(address, value, M68K);
 325         else if ((address >= 0xF00000) && (address <= 0xF0FFFF))
 326                 TOMWriteByte(address, value, M68K);
 327         else if ((address >= 0xF10000) && (address <= 0xF1FFFF))
 328                 JERRYWriteByte(address, value, M68K);
 329         else
 330                 jaguar_unknown_writebyte(address, value, M68K);
 331 }
 332
 333 void m68k_write_memory_16(unsigned int address, unsigned int value)
 334 {
 335 #ifdef CPU_DEBUG_MEMORY
 336         if ((address >= 0x000000) && (address <= 0x3FFFFE))
 337         {
 338                 if (startMemLog)
 339                 {
 340                         uint8 hi = value >> 8, lo = value & 0xFF;
 341
 342                         if (hi > writeMemMax[address])
 343                                 writeMemMax[address] = hi;
 344                         if (hi < writeMemMin[address])
 345                                 writeMemMin[address] = hi;
 346
 347                         if (lo > writeMemMax[address+1])
 348                                 writeMemMax[address+1] = lo;
 349                         if (lo < writeMemMin[address+1])
 350                                 writeMemMin[address+1] = lo;
 351                 }
 352         }
 353 #endif
 354 //if ((address >= 0x1FF020 && address <= 0x1FF03F) || (address >= 0x1FF820 && address <= 0x1FF83F))
 355 //      WriteLog("M68K: Writing %04X at %08X\n", value, address);
 356 //WriteLog("[WM16 PC=%08X] Addr: %08X, val: %04X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);
 357 //if (address >= 0xF02200 && address <= 0xF0229F)
 358 //      WriteLog("M68K: Writing to blitter --> %04X at %08X\n", value, address);
 359 //if (address >= 0x0E75D0 && address <= 0x0E75E7)
 360 //      WriteLog("M68K: Writing %04X at %08X, M68K PC=%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));
 361 /*extern uint32 totalFrames;
 362 if (address == 0xF02114)
 363         WriteLog("M68K: Writing to GPU_CTRL (frame:%u)... [M68K PC:%08X]\n", totalFrames, m68k_get_reg(NULL, M68K_REG_PC));
 364 if (address == 0xF02110)
 365         WriteLog("M68K: Writing to GPU_PC (frame:%u)... [M68K PC:%08X]\n", totalFrames, m68k_get_reg(NULL, M68K_REG_PC));//*/
 366 //if (address >= 0xF03B00 && address <= 0xF03DFF)
 367 //      WriteLog("M68K: Writing %04X to %08X...\n", value, address);
 368
 369         if ((address >= 0x000000) && (address <= 0x3FFFFE))
 370         {
 371 /*              jaguar_mainRam[address] = value >> 8;
 372                 jaguar_mainRam[address + 1] = value & 0xFF;*/
 373                 SET16(jaguar_mainRam, address, value);
 374         }
 375         else if ((address >= 0xDFFF00) && (address <= 0xDFFFFE))
 376                 CDROMWriteWord(address, value, M68K);
 377         else if ((address >= 0xF00000) && (address <= 0xF0FFFE))
 378                 TOMWriteWord(address, value, M68K);
 379         else if ((address >= 0xF10000) && (address <= 0xF1FFFE))
 380                 JERRYWriteWord(address, value, M68K);
 381         else
 382         {
 383                 jaguar_unknown_writeword(address, value, M68K);
 384 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
 385                 WriteLog("\tA0=%08X, A1=%08X, D0=%08X, D1=%08X\n",
 386                         m68k_get_reg(NULL, M68K_REG_A0), m68k_get_reg(NULL, M68K_REG_A1),
 387                         m68k_get_reg(NULL, M68K_REG_D0), m68k_get_reg(NULL, M68K_REG_D1));
 388 #endif
 389         }
 390 }
 391
 392 void m68k_write_memory_32(unsigned int address, unsigned int value)
 393 {
 394 //WriteLog("--> [WM32]\n");
 395         m68k_write_memory_16(address, value >> 16);
 396         m68k_write_memory_16(address + 2, value & 0xFFFF);
 397 }
 398
 399
 400 uint32 jaguar_get_handler(uint32 i)
 401 {
 402         return JaguarReadLong(i * 4);
 403 }
 404
 405 uint32 jaguar_interrupt_handler_is_valid(uint32 i)
 406 {
 407         uint32 handler = jaguar_get_handler(i);
 408         if (handler && (handler != 0xFFFFFFFF))
 409                 return 1;
 410         else
 411                 return 0;
 412 }
 413
 414 void M68K_show_context(void)
 415 {
 416         WriteLog("\t68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC));
 417         for(int i=M68K_REG_D0; i<=M68K_REG_D7; i++)
 418                 WriteLog("\tD%i = %08X\n", i-M68K_REG_D0, m68k_get_reg(NULL, (m68k_register_t)i));
 419         WriteLog("\n");
 420         for(int i=M68K_REG_A0; i<=M68K_REG_A7; i++)
 421                 WriteLog("\tA%i = %08X\n", i-M68K_REG_A0, m68k_get_reg(NULL, (m68k_register_t)i));
 422
 423         WriteLog("68K disasm\n");
 424 //      jaguar_dasm(s68000readPC()-0x1000,0x20000);
 425         jaguar_dasm(m68k_get_reg(NULL, M68K_REG_PC) - 0x80, 0x200);
 426 //      jaguar_dasm(0x5000, 0x14414);
 427
 428         WriteLog("..................\n");
 429
 430         if (tom_irq_enabled(IRQ_VBLANK))
 431         {
 432                 WriteLog("vblank int: enabled\n");
 433                 jaguar_dasm(jaguar_get_handler(64), 0x200);
 434         }
 435         else
 436                 WriteLog("vblank int: disabled\n");
 437
 438         WriteLog("..................\n");
 439
 440         for(int i=0; i<256; i++)
 441                 WriteLog("handler %03i at $%08X\n", i, (unsigned int)jaguar_get_handler(i));
 442 }
 443
 444 //
 445 // Unknown read/write byte/word routines
 446 //
 447
 448 // It's hard to believe that developers would be sloppy with their memory writes, yet in
 449 // some cases the developers screwed up royal. E.g., Club Drive has the following code:
 450 //
 451 // 807EC4: movea.l #$f1b000, A1
 452 // 807ECA: movea.l #$8129e0, A0
 453 // 807ED0: move.l  A0, D0
 454 // 807ED2: move.l  #$f1bb94, D1
 455 // 807ED8: sub.l   D0, D1
 456 // 807EDA: lsr.l   #2, D1
 457 // 807EDC: move.l  (A0)+, (A1)+
 458 // 807EDE: dbra    D1, 807edc
 459 //
 460 // The problem is at $807ED0--instead of putting A0 into D0, they really meant to put A1
 461 // in. This mistake causes it to try and overwrite approximately $700000 worth of address
 462 // space! (That is, unless the 68K causes a bus error...)
 463
 464 void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32 who/*=UNKNOWN*/)
 465 {
 466 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
 467         WriteLog("Jaguar: Unknown byte %02X written at %08X by %s (M68K PC=%06X)\n", data, address, whoName[who], m68k_get_reg(NULL, M68K_REG_PC));
 468 #endif
 469 #ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS
 470         extern bool finished;
 471         finished = true;
 472         extern bool doDSPDis;
 473         if (who == DSP)
 474                 doDSPDis = true;
 475 #endif
 476 }
 477
 478 void jaguar_unknown_writeword(unsigned address, unsigned data, uint32 who/*=UNKNOWN*/)
 479 {
 480 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
 481         WriteLog("Jaguar: Unknown word %04X written at %08X by %s (M68K PC=%06X)\n", data, address, whoName[who], m68k_get_reg(NULL, M68K_REG_PC));
 482 #endif
 483 #ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS
 484         extern bool finished;
 485         finished = true;
 486         extern bool doDSPDis;
 487         if (who == DSP)
 488                 doDSPDis = true;
 489 #endif
 490 }
 491
 492 unsigned jaguar_unknown_readbyte(unsigned address, uint32 who/*=UNKNOWN*/)
 493 {
 494 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
 495         WriteLog("Jaguar: Unknown byte read at %08X by %s (M68K PC=%06X)\n", address, whoName[who], m68k_get_reg(NULL, M68K_REG_PC));
 496 #endif
 497 #ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS
 498         extern bool finished;
 499         finished = true;
 500         extern bool doDSPDis;
 501         if (who == DSP)
 502                 doDSPDis = true;
 503 #endif
 504     return 0xFF;
 505 }
 506
 507 unsigned jaguar_unknown_readword(unsigned address, uint32 who/*=UNKNOWN*/)
 508 {
 509 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
 510         WriteLog("Jaguar: Unknown word read at %08X by %s (M68K PC=%06X)\n", address, whoName[who], m68k_get_reg(NULL, M68K_REG_PC));
 511 #endif
 512 #ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS
 513         extern bool finished;
 514         finished = true;
 515         extern bool doDSPDis;
 516         if (who == DSP)
 517                 doDSPDis = true;
 518 #endif
 519     return 0xFFFF;
 520 }
 521
 522 //
 523 // Disassemble M68K instructions at the given offset
 524 //
 525
 526 unsigned int m68k_read_disassembler_8(unsigned int address)
 527 {
 528         return m68k_read_memory_8(address);
 529 }
 530
 531 unsigned int m68k_read_disassembler_16(unsigned int address)
 532 {
 533         return m68k_read_memory_16(address);
 534 }
 535
 536 unsigned int m68k_read_disassembler_32(unsigned int address)
 537 {
 538         return m68k_read_memory_32(address);
 539 }
 540
 541 void jaguar_dasm(uint32 offset, uint32 qt)
 542 {
 543 #ifdef CPU_DEBUG
 544         static char buffer[2048];//, mem[64];
 545         int pc = offset, oldpc;
 546
 547         for(uint32 i=0; i<qt; i++)
 548         {
 549 /*              oldpc = pc;
 550                 for(int j=0; j<64; j++)
 551                         mem[j^0x01] = jaguar_byte_read(pc + j);
 552
 553                 pc += Dasm68000((char *)mem, buffer, 0);
 554                 WriteLog("%08X: %s\n", oldpc, buffer);//*/
 555                 oldpc = pc;
 556                 pc += m68k_disassemble(buffer, pc, M68K_CPU_TYPE_68000);
 557                 WriteLog("%08X: %s\n", oldpc, buffer);//*/
 558         }
 559 #endif
 560 }
 561
 562 uint8 JaguarReadByte(uint32 offset, uint32 who/*=UNKNOWN*/)
 563 {
 564         uint8 data = 0x00;
 565
 566         offset &= 0xFFFFFF;
 567         if (offset < 0x400000)
 568                 data = jaguar_mainRam[offset & 0x3FFFFF];
 569         else if ((offset >= 0x800000) && (offset < 0xC00000))
 570                 data = jaguar_mainRom[offset - 0x800000];
 571         else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFF))
 572                 data = CDROMReadByte(offset, who);
 573         else if ((offset >= 0xE00000) && (offset < 0xE40000))
 574                 data = jaguar_bootRom[offset & 0x3FFFF];
 575         else if ((offset >= 0xF00000) && (offset < 0xF10000))
 576                 data = TOMReadByte(offset, who);
 577         else if ((offset >= 0xF10000) && (offset < 0xF20000))
 578                 data = JERRYReadByte(offset, who);
 579         else
 580                 data = jaguar_unknown_readbyte(offset, who);
 581
 582         return data;
 583 }
 584
 585 uint16 JaguarReadWord(uint32 offset, uint32 who/*=UNKNOWN*/)
 586 {
 587         offset &= 0xFFFFFF;
 588         if (offset <= 0x3FFFFE)
 589         {
 590                 return (jaguar_mainRam[(offset+0) & 0x3FFFFF] << 8) | jaguar_mainRam[(offset+1) & 0x3FFFFF];
 591         }
 592         else if ((offset >= 0x800000) && (offset <= 0xBFFFFE))
 593         {
 594                 offset -= 0x800000;
 595                 return (jaguar_mainRom[offset+0] << 8) | jaguar_mainRom[offset+1];
 596         }
 597 //      else if ((offset >= 0xDFFF00) && (offset < 0xDFFF00))
 598         else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFE))
 599                 return CDROMReadWord(offset, who);
 600         else if ((offset >= 0xE00000) && (offset <= 0xE3FFFE))
 601                 return (jaguar_bootRom[(offset+0) & 0x3FFFF] << 8) | jaguar_bootRom[(offset+1) & 0x3FFFF];
 602         else if ((offset >= 0xF00000) && (offset <= 0xF0FFFE))
 603                 return TOMReadWord(offset, who);
 604         else if ((offset >= 0xF10000) && (offset <= 0xF1FFFE))
 605                 return JERRYReadWord(offset, who);
 606
 607         return jaguar_unknown_readword(offset, who);
 608 }
 609
 610 void JaguarWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/)
 611 {
 612         offset &= 0xFFFFFF;
 613         if (offset < 0x400000)
 614         {
 615                 jaguar_mainRam[offset & 0x3FFFFF] = data;
 616                 return;
 617         }
 618         else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFF))
 619         {
 620                 CDROMWriteByte(offset, data, who);
 621                 return;
 622         }
 623         else if ((offset >= 0xF00000) && (offset <= 0xF0FFFF))
 624         {
 625                 TOMWriteByte(offset, data, who);
 626                 return;
 627         }
 628         else if ((offset >= 0xF10000) && (offset <= 0xF1FFFF))
 629         {
 630                 JERRYWriteByte(offset, data, who);
 631                 return;
 632         }
 633
 634         jaguar_unknown_writebyte(offset, data, who);
 635 }
 636
 637 void JaguarWriteWord(uint32 offset, uint16 data, uint32 who/*=UNKNOWN*/)
 638 {
 639 //TEMP--Mirror of F03000? Yes, but only 32-bit CPUs can do it (i.e., NOT the 68K!)
 640 // PLUS, you would handle this in the GPU/DSP WriteLong code! Not here!
 641         offset &= 0xFFFFFF;
 642
 643         if (offset <= 0x3FFFFE)
 644         {
 645 //This MUST be done by the 68K!
 646 /*if (offset == 0x670C)
 647         WriteLog("Jaguar: %s writing to location $670C...\n", whoName[who]);*/
 648
 649                 jaguar_mainRam[(offset+0) & 0x3FFFFF] = (data>>8) & 0xFF;
 650                 jaguar_mainRam[(offset+1) & 0x3FFFFF] = data & 0xFF;
 651                 return;
 652         }
 653         else if (offset >= 0xDFFF00 && offset <= 0xDFFFFE)
 654         {
 655                 CDROMWriteWord(offset, data, who);
 656                 return;
 657         }
 658         else if (offset >= 0xF00000 && offset <= 0xF0FFFE)
 659         {
 660                 TOMWriteWord(offset, data, who);
 661                 return;
 662         }
 663         else if (offset >= 0xF10000 && offset <= 0xF1FFFE)
 664         {
 665                 JERRYWriteWord(offset, data, who);
 666                 return;
 667         }
 668         // Don't bomb on attempts to write to ROM
 669         else if (offset >= 0x800000 && offset <= 0xEFFFFF)
 670                 return;
 671
 672         jaguar_unknown_writeword(offset, data, who);
 673 }
 674
 675 // We really should re-do this so that it does *real* 32-bit access... !!! FIX !!!
 676 uint32 JaguarReadLong(uint32 offset, uint32 who/*=UNKNOWN*/)
 677 {
 678         return (JaguarReadWord(offset, who) << 16) | JaguarReadWord(offset+2, who);
 679 }
 680
 681 // We really should re-do this so that it does *real* 32-bit access... !!! FIX !!!
 682 void JaguarWriteLong(uint32 offset, uint32 data, uint32 who/*=UNKNOWN*/)
 683 {
 684 /*      extern bool doDSPDis;
 685         if (offset < 0x400 && !doDSPDis)
 686         {
 687                 WriteLog("JLW: Write to %08X by %s... Starting DSP log!\n\n", offset, whoName[who]);
 688                 doDSPDis = true;
 689         }//*/
 690
 691         JaguarWriteWord(offset, data >> 16, who);
 692         JaguarWriteWord(offset+2, data & 0xFFFF, who);
 693 }
 694
 695 //
 696 // Jaguar console initialization
 697 //
 698 void jaguar_init(void)
 699 {
 700 #ifdef CPU_DEBUG_MEMORY
 701         memset(readMem, 0x00, 0x400000);
 702         memset(writeMemMin, 0xFF, 0x400000);
 703         memset(writeMemMax, 0x00, 0x400000);
 704 #endif
 705         memory_malloc_secure((void **)&jaguar_mainRam, 0x400000, "Jaguar 68K CPU RAM");
 706         memory_malloc_secure((void **)&jaguar_bootRom, 0x040000, "Jaguar 68K CPU BIOS ROM");
 707         memory_malloc_secure((void **)&jaguar_mainRom, 0x600000, "Jaguar 68K CPU ROM");
 708         memset(jaguar_mainRam, 0x00, 0x400000);
 709 //      memset(jaguar_mainRom, 0xFF, 0x200000); // & set it to all Fs...
 710 //      memset(jaguar_mainRom, 0x00, 0x200000); // & set it to all 0s...
 711 //NOTE: This *doesn't* fix FlipOut...
 712         memset(jaguar_mainRom, 0x01, 0x600000); // & set it to all 01s...
 713
 714 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\Brain Dead 13.cdi");
 715 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\baldies.cdi");
 716 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\mystdemo.cdi");
 717 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\battlemorph.cdi");
 718 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\primalrage.cdi");
 719 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\Dragons Lair.cdi");
 720
 721         m68k_set_cpu_type(M68K_CPU_TYPE_68000);
 722         gpu_init();
 723         DSPInit();
 724         tom_init();
 725         jerry_init();
 726         cdrom_init();
 727 }
 728
 729 void jaguar_done(void)
 730 {
 731 #ifdef CPU_DEBUG_MEMORY
 732 /*      WriteLog("\n\nM68000 disassembly at $8D0D44 (collision routine!)...\n");
 733         jaguar_dasm(0x8D0D44, 5000);
 734         WriteLog("\n");//*/
 735 /*      WriteLog("\n\nM68000 disassembly at $806300 (look @ $806410)...\n");
 736         jaguar_dasm(0x806300, 5000);
 737         WriteLog("\n");//*/
 738
 739 /*      WriteLog("\nJaguar: Memory Usage Stats (return addresses)\n\n");
 740
 741         for(uint32 i=0; i<=raPtr; i++)
 742         {
 743                 WriteLog("\t%08X\n", returnAddr[i]);
 744                 WriteLog("M68000 disassembly at $%08X...\n", returnAddr[i] - 16);
 745                 jaguar_dasm(returnAddr[i] - 16, 16);
 746                 WriteLog("\n");
 747         }
 748         WriteLog("\n");//*/
 749
 750 /*      int start = 0, end = 0;
 751         bool endTriggered = false, startTriggered = false;
 752         for(int i=0; i<0x400000; i++)
 753         {
 754                 if (readMem[i] && writeMemMin[i] != 0xFF && writeMemMax != 0x00)
 755                 {
 756                         if (!startTriggered)
 757                                 startTriggered = true, endTriggered = false, start = i;
 758
 759                         WriteLog("\t\tMin/Max @ %06X: %u/%u\n", i, writeMemMin[i], writeMemMax[i]);
 760                 }
 761                 else
 762                 {
 763                         if (!endTriggered)
 764                         {
 765                                 end = i - 1, endTriggered = true, startTriggered = false;
 766                                 WriteLog("\tMemory range accessed: %06X - %06X\n", start, end);
 767                         }
 768                 }
 769         }
 770         WriteLog("\n");//*/
 771 #endif
 772 //#ifdef CPU_DEBUG
 773 //      for(int i=M68K_REG_A0; i<=M68K_REG_A7; i++)
 774 //              WriteLog("\tA%i = 0x%.8x\n", i-M68K_REG_A0, m68k_get_reg(NULL, (m68k_register_t)i));
 775         int32 topOfStack = m68k_get_reg(NULL, M68K_REG_A7);
 776         WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack));
 777         for(int i=-2; i<9; i++)
 778                 WriteLog("%06X: %08X\n", topOfStack + (i * 4), JaguarReadLong(topOfStack + (i * 4)));
 779
 780 /*      WriteLog("\nM68000 disassembly at $802288...\n");
 781         jaguar_dasm(0x802288, 3);
 782         WriteLog("\nM68000 disassembly at $802200...\n");
 783         jaguar_dasm(0x802200, 500);
 784         WriteLog("\nM68000 disassembly at $802518...\n");
 785         jaguar_dasm(0x802518, 100);//*/
 786
 787 /*      WriteLog("\n\nM68000 disassembly at $803F00 (look @ $803F2A)...\n");
 788         jaguar_dasm(0x803F00, 500);
 789         WriteLog("\n");//*/
 790
 791 /*      WriteLog("\n\nM68000 disassembly at $802B00 (look @ $802B5E)...\n");
 792         jaguar_dasm(0x802B00, 500);
 793         WriteLog("\n");//*/
 794
 795 /*      WriteLog("\n\nM68000 disassembly at $809900 (look @ $8099F8)...\n");
 796         jaguar_dasm(0x809900, 500);
 797         WriteLog("\n");//*/
 798 //8099F8
 799 /*      WriteLog("\n\nDump of $8093C8:\n\n");
 800         for(int i=0x8093C8; i<0x809900; i+=4)
 801                 WriteLog("%06X: %08X\n", i, JaguarReadLong(i));//*/
 802 /*      WriteLog("\n\nM68000 disassembly at $90006C...\n");
 803         jaguar_dasm(0x90006C, 500);
 804         WriteLog("\n");//*/
 805
 806 //      WriteLog("Jaguar: CD BIOS version %04X\n", JaguarReadWord(0x3004));
 807         WriteLog("Jaguar: Interrupt enable = %02X\n", TOMReadByte(0xF000E1) & 0x1F);
 808         WriteLog("Jaguar: VBL interrupt is %s\n", ((tom_irq_enabled(IRQ_VBLANK)) && (jaguar_interrupt_handler_is_valid(64))) ? "enabled" : "disabled");
 809         M68K_show_context();
 810 //#endif
 811
 812         cd_bios_done();
 813         cdrom_done();
 814         gpu_done();
 815         DSPDone();
 816         tom_done();
 817         jerry_done();
 818
 819         memory_free(jaguar_mainRom);
 820         memory_free(jaguar_bootRom);
 821         memory_free(jaguar_mainRam);
 822 }
 823
 824 void jaguar_reset(void)
 825 {
 826         if (vjs.useJaguarBIOS)
 827                 memcpy(jaguar_mainRam, jaguar_bootRom, 8);
 828         else
 829         {
 830 // Should also make a run address global as well, for when we reset the jag (PD mainly)
 831 /*              SET32(jaguar_mainRam, 4, 0x00802000);
 832                 // Handle PD stuff...
 833                 // This should definitely go elsewhere (like in the cart load section)!
 834 //NOTE: The bytes 'JAGR' should also be at position $1C...
 835                 if (jaguar_mainRom[0] == 0x60 && jaguar_mainRom[1] == 0x1A)
 836                 {
 837                         uint32 loadAddress = GET32(jaguar_mainRom, 0x22), runAddress = GET32(jaguar_mainRom, 0x2A);
 838 //This is not always right! Especially when converted via bin2jag1!!!
 839 //We should have access to the length of the furshlumiger file that was loaded anyway!
 840 //Now, we do! ;-)
 841 //                      uint32 progLength = GET32(jaguar_mainRom, 0x02);
 842 //jaguarRomSize
 843 //jaguarRunAddress
 844 //                      WriteLog("Jaguar: Setting up PD ROM... Run address: %08X, length: %08X\n", runAddress, progLength);
 845 //                      memcpy(jaguar_mainRam + loadAddress, jaguar_mainRom + 0x2E, progLength);
 846                         WriteLog("Jaguar: Setting up PD ROM... Run address: %08X, length: %08X\n", runAddress, jaguarRomSize - 0x2E);
 847                         memcpy(jaguar_mainRam + loadAddress, jaguar_mainRom + 0x2E, jaguarRomSize - 0x2E);
 848                         SET32(jaguar_mainRam, 4, runAddress);
 849                 }//*/
 850                 SET32(jaguar_mainRam, 4, jaguarRunAddress);
 851         }
 852
 853 //      WriteLog("jaguar_reset():\n");
 854 //#ifdef SOUND_OUTPUT
 855 //      ws_audio_reset();
 856 //#endif
 857         cd_bios_reset();
 858         tom_reset();
 859         jerry_reset();
 860         gpu_reset();
 861         DSPReset();
 862         cdrom_reset();
 863     m68k_pulse_reset();                         // Reset the 68000
 864         WriteLog("\t68K PC=%06X SP=%08X\n", m68k_get_reg(NULL, M68K_REG_PC), m68k_get_reg(NULL, M68K_REG_A7));
 865 }
 866
 867 //
 868 // Main Jaguar execution loop (1 frame)
 869 //
 870 void JaguarExecute(int16 * backbuffer, bool render)
 871 {
 872         uint16 vp = TOMReadWord(0xF0003E) + 1;//Hmm. This is a WO register. Will work? Looks like. But wrong behavior!
 873         uint16 vi = TOMReadWord(0xF0004E);//Another WO register...
 874 //      uint16 vdb = TOMReadWord(0xF00046);
 875 //Note: This is the *definite* end of the display, though VDE *might* be less than this...
 876 //      uint16 vbb = TOMReadWord(0xF00040);
 877 //It seems that they mean it when they say that VDE is the end of object processing.
 878 //However, we need to be able to tell the OP (or TOM) that we've reached the end of the
 879 //buffer and not to write any more pixels... !!! FIX !!!
 880 //      uint16 vde = TOMReadWord(0xF00048);
 881
 882         uint16 refreshRate = (vjs.hardwareTypeNTSC ? 60 : 50);
 883         // Should these be hardwired or read from VP? Yes, from VP!
 884         uint32 M68KCyclesPerScanline
 885                 = (vjs.hardwareTypeNTSC ? M68K_CLOCK_RATE_NTSC : M68K_CLOCK_RATE_PAL) / (vp * refreshRate);
 886         uint32 RISCCyclesPerScanline
 887                 = (vjs.hardwareTypeNTSC ? RISC_CLOCK_RATE_NTSC : RISC_CLOCK_RATE_PAL) / (vp * refreshRate);
 888
 889         TOMResetBackbuffer(backbuffer);
 890 /*extern int effect_start;
 891 if (effect_start)
 892 {
 893         WriteLog("JagExe: VP=%u, VI=%u, VDB=%u, VBB=%u CPU CPS=%u, GPU CPS=%u\n", vp, vi, vdb, vbb, M68KCyclesPerScanline, RISCCyclesPerScanline);
 894 }//*/
 895
 896 //extern int start_logging;
 897         for(uint16 i=0; i<vp; i++)
 898         {
 899                 // Increment the horizontal count (why? RNG?)
 900                 TOMWriteWord(0xF00004, (TOMReadWord(0xF00004) + 1) & 0x7FF);
 901
 902                 TOMWriteWord(0xF00006, i);                                      // Write the VC
 903
 904                 if (i == vi)                                                            // Time for Vertical Interrupt?
 905                 {
 906                         if (tom_irq_enabled(IRQ_VBLANK))// && jaguar_interrupt_handler_is_valid(64))
 907                         {
 908                                 // We don't have to worry about autovectors & whatnot because the Jaguar
 909                                 // tells you through its HW registers who sent the interrupt...
 910                                 tom_set_pending_video_int();
 911                                 m68k_set_irq(7);
 912                         }
 913                 }
 914
 915 //              uint32 invalid_instruction_address = s68000exec(M68KCyclesPerScanline);
 916 //              if (invalid_instruction_address != 0x80000000)
 917 //                      cd_bios_process(invalid_instruction_address);
 918 //if (start_logging)
 919 //      WriteLog("About to execute M68K (%u)...\n", i);
 920                 m68k_execute(M68KCyclesPerScanline);
 921                 // No CD handling... !!! FIX !!!
 922 //if (start_logging)
 923 //      WriteLog("About to execute CD BIOS (%u)...\n", i);
 924                 cd_bios_exec(i);        // NOTE: Ignores parameter...
 925 //if (start_logging)
 926 //      WriteLog("About to execute TOM's PIT (%u)...\n", i);
 927                 TOMExecPIT(RISCCyclesPerScanline);
 928 //if (start_logging)
 929 //      WriteLog("About to execute JERRY's PIT (%u)...\n", i);
 930                 jerry_pit_exec(RISCCyclesPerScanline);
 931 //if (start_logging)
 932 //      WriteLog("About to execute JERRY's SSI (%u)...\n", i);
 933                 jerry_i2s_exec(RISCCyclesPerScanline);
 934 //if (start_logging)
 935 //      WriteLog("About to execute GPU (%u)...\n", i);
 936                 gpu_exec(RISCCyclesPerScanline);
 937
 938                 if (vjs.DSPEnabled)
 939                         if (vjs.usePipelinedDSP)
 940                                 DSPExecP2(RISCCyclesPerScanline);       // Pipelined DSP execution (3 stage)...
 941                         else
 942                                 DSPExec(RISCCyclesPerScanline);         // Ordinary non-pipelined DSP
 943 //                      DSPExecComp(RISCCyclesPerScanline);             // Comparison core
 944
 945 //if (start_logging)
 946 //      WriteLog("About to execute OP (%u)...\n", i);
 947                 TOMExecScanline(i, render);
 948         }
 949 }
 950
 951 // Temp debugging stuff
 952
 953 void DumpMainMemory(void)
 954 {
 955         FILE * fp = fopen("./memdump.bin", "wb");
 956
 957         if (fp == NULL)
 958                 return;
 959
 960         fwrite(jaguar_mainRam, 1, 0x400000, fp);
 961         fclose(fp);
 962 }
 963
 964 uint8 * GetRamPtr(void)
 965 {
 966         return jaguar_mainRam;
 967 }