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