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                 WriteLog("\tA0=%08X, A1=%08X, D0=%08X, D1=%08X\n",
 385                         m68k_get_reg(NULL, M68K_REG_A0), m68k_get_reg(NULL, M68K_REG_A1),
 386                         m68k_get_reg(NULL, M68K_REG_D0), m68k_get_reg(NULL, M68K_REG_D1));
 387         }
 388 }
 389
 390 void m68k_write_memory_32(unsigned int address, unsigned int value)
 391 {
 392 //WriteLog("--> [WM32]\n");
 393         m68k_write_memory_16(address, value >> 16);
 394         m68k_write_memory_16(address + 2, value & 0xFFFF);
 395 }
 396
 397
 398 uint32 jaguar_get_handler(uint32 i)
 399 {
 400         return JaguarReadLong(i * 4);
 401 }
 402
 403 uint32 jaguar_interrupt_handler_is_valid(uint32 i)
 404 {
 405         uint32 handler = jaguar_get_handler(i);
 406         if (handler && (handler != 0xFFFFFFFF))
 407                 return 1;
 408         else
 409                 return 0;
 410 }
 411
 412 void M68K_show_context(void)
 413 {
 414         WriteLog("\t68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC));
 415         for(int i=M68K_REG_D0; i<=M68K_REG_D7; i++)
 416                 WriteLog("\tD%i = %08X\n", i-M68K_REG_D0, m68k_get_reg(NULL, (m68k_register_t)i));
 417         WriteLog("\n");
 418         for(int i=M68K_REG_A0; i<=M68K_REG_A7; i++)
 419                 WriteLog("\tA%i = %08X\n", i-M68K_REG_A0, m68k_get_reg(NULL, (m68k_register_t)i));
 420
 421         WriteLog("68K disasm\n");
 422 //      jaguar_dasm(s68000readPC()-0x1000,0x20000);
 423         jaguar_dasm(m68k_get_reg(NULL, M68K_REG_PC) - 0x80, 0x200);
 424 //      jaguar_dasm(0x5000, 0x14414);
 425
 426         WriteLog("..................\n");
 427
 428         if (tom_irq_enabled(IRQ_VBLANK))
 429         {
 430                 WriteLog("vblank int: enabled\n");
 431                 jaguar_dasm(jaguar_get_handler(64), 0x200);
 432         }
 433         else
 434                 WriteLog("vblank int: disabled\n");
 435
 436         WriteLog("..................\n");
 437
 438         for(int i=0; i<256; i++)
 439                 WriteLog("handler %03i at $%08X\n", i, (unsigned int)jaguar_get_handler(i));
 440 }
 441
 442 //
 443 // Unknown read/write byte/word routines
 444 //
 445
 446 // It's hard to believe that developers would be sloppy with their memory writes, yet in
 447 // some cases the developers screwed up royal. E.g., Club Drive has the following code:
 448 //
 449 // 807EC4: movea.l #$f1b000, A1
 450 // 807ECA: movea.l #$8129e0, A0
 451 // 807ED0: move.l  A0, D0
 452 // 807ED2: move.l  #$f1bb94, D1
 453 // 807ED8: sub.l   D0, D1
 454 // 807EDA: lsr.l   #2, D1
 455 // 807EDC: move.l  (A0)+, (A1)+
 456 // 807EDE: dbra    D1, 807edc
 457 //
 458 // The problem is at $807ED0--instead of putting A0 into D0, they really meant to put A1
 459 // in. This mistake causes it to try and overwrite approximately $700000 worth of address
 460 // space! (That is, unless the 68K causes a bus error...)
 461
 462 void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32 who/*=UNKNOWN*/)
 463 {
 464 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
 465         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));
 466 #endif
 467 #ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS
 468         extern bool finished;
 469         finished = true;
 470         extern bool doDSPDis;
 471         if (who == DSP)
 472                 doDSPDis = true;
 473 #endif
 474 }
 475
 476 void jaguar_unknown_writeword(unsigned address, unsigned data, uint32 who/*=UNKNOWN*/)
 477 {
 478 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
 479         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));
 480 #endif
 481 #ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS
 482         extern bool finished;
 483         finished = true;
 484         extern bool doDSPDis;
 485         if (who == DSP)
 486                 doDSPDis = true;
 487 #endif
 488 }
 489
 490 unsigned jaguar_unknown_readbyte(unsigned address, uint32 who/*=UNKNOWN*/)
 491 {
 492 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
 493         WriteLog("Jaguar: Unknown byte read at %08X by %s (M68K PC=%06X)\n", 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     return 0xFF;
 503 }
 504
 505 unsigned jaguar_unknown_readword(unsigned address, uint32 who/*=UNKNOWN*/)
 506 {
 507 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
 508         WriteLog("Jaguar: Unknown word read at %08X by %s (M68K PC=%06X)\n", address, whoName[who], m68k_get_reg(NULL, M68K_REG_PC));
 509 #endif
 510 #ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS
 511         extern bool finished;
 512         finished = true;
 513         extern bool doDSPDis;
 514         if (who == DSP)
 515                 doDSPDis = true;
 516 #endif
 517     return 0xFFFF;
 518 }
 519
 520 //
 521 // Disassemble M68K instructions at the given offset
 522 //
 523
 524 unsigned int m68k_read_disassembler_8(unsigned int address)
 525 {
 526         return m68k_read_memory_8(address);
 527 }
 528
 529 unsigned int m68k_read_disassembler_16(unsigned int address)
 530 {
 531         return m68k_read_memory_16(address);
 532 }
 533
 534 unsigned int m68k_read_disassembler_32(unsigned int address)
 535 {
 536         return m68k_read_memory_32(address);
 537 }
 538
 539 void jaguar_dasm(uint32 offset, uint32 qt)
 540 {
 541 #ifdef CPU_DEBUG
 542         static char buffer[2048];//, mem[64];
 543         int pc = offset, oldpc;
 544
 545         for(uint32 i=0; i<qt; i++)
 546         {
 547 /*              oldpc = pc;
 548                 for(int j=0; j<64; j++)
 549                         mem[j^0x01] = jaguar_byte_read(pc + j);
 550
 551                 pc += Dasm68000((char *)mem, buffer, 0);
 552                 WriteLog("%08X: %s\n", oldpc, buffer);//*/
 553                 oldpc = pc;
 554                 pc += m68k_disassemble(buffer, pc, M68K_CPU_TYPE_68000);
 555                 WriteLog("%08X: %s\n", oldpc, buffer);//*/
 556         }
 557 #endif
 558 }
 559
 560 uint8 JaguarReadByte(uint32 offset, uint32 who/*=UNKNOWN*/)
 561 {
 562         uint8 data = 0x00;
 563
 564         offset &= 0xFFFFFF;
 565         if (offset < 0x400000)
 566                 data = jaguar_mainRam[offset & 0x3FFFFF];
 567         else if ((offset >= 0x800000) && (offset < 0xC00000))
 568                 data = jaguar_mainRom[offset - 0x800000];
 569         else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFF))
 570                 data = CDROMReadByte(offset, who);
 571         else if ((offset >= 0xE00000) && (offset < 0xE40000))
 572                 data = jaguar_bootRom[offset & 0x3FFFF];
 573         else if ((offset >= 0xF00000) && (offset < 0xF10000))
 574                 data = TOMReadByte(offset, who);
 575         else if ((offset >= 0xF10000) && (offset < 0xF20000))
 576                 data = JERRYReadByte(offset, who);
 577         else
 578                 data = jaguar_unknown_readbyte(offset, who);
 579
 580         return data;
 581 }
 582
 583 uint16 JaguarReadWord(uint32 offset, uint32 who/*=UNKNOWN*/)
 584 {
 585         offset &= 0xFFFFFF;
 586         if (offset <= 0x3FFFFE)
 587         {
 588                 return (jaguar_mainRam[(offset+0) & 0x3FFFFF] << 8) | jaguar_mainRam[(offset+1) & 0x3FFFFF];
 589         }
 590         else if ((offset >= 0x800000) && (offset <= 0xBFFFFE))
 591         {
 592                 offset -= 0x800000;
 593                 return (jaguar_mainRom[offset+0] << 8) | jaguar_mainRom[offset+1];
 594         }
 595 //      else if ((offset >= 0xDFFF00) && (offset < 0xDFFF00))
 596         else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFE))
 597                 return CDROMReadWord(offset, who);
 598         else if ((offset >= 0xE00000) && (offset <= 0xE3FFFE))
 599                 return (jaguar_bootRom[(offset+0) & 0x3FFFF] << 8) | jaguar_bootRom[(offset+1) & 0x3FFFF];
 600         else if ((offset >= 0xF00000) && (offset <= 0xF0FFFE))
 601                 return TOMReadWord(offset, who);
 602         else if ((offset >= 0xF10000) && (offset <= 0xF1FFFE))
 603                 return JERRYReadWord(offset, who);
 604
 605         return jaguar_unknown_readword(offset, who);
 606 }
 607
 608 void JaguarWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/)
 609 {
 610         offset &= 0xFFFFFF;
 611         if (offset < 0x400000)
 612         {
 613                 jaguar_mainRam[offset & 0x3FFFFF] = data;
 614                 return;
 615         }
 616         else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFF))
 617         {
 618                 CDROMWriteByte(offset, data, who);
 619                 return;
 620         }
 621         else if ((offset >= 0xF00000) && (offset <= 0xF0FFFF))
 622         {
 623                 TOMWriteByte(offset, data, who);
 624                 return;
 625         }
 626         else if ((offset >= 0xF10000) && (offset <= 0xF1FFFF))
 627         {
 628                 JERRYWriteByte(offset, data, who);
 629                 return;
 630         }
 631
 632         jaguar_unknown_writebyte(offset, data, who);
 633 }
 634
 635 void JaguarWriteWord(uint32 offset, uint16 data, uint32 who/*=UNKNOWN*/)
 636 {
 637 //TEMP--Mirror of F03000? Yes, but only 32-bit CPUs can do it (i.e., NOT the 68K!)
 638 // PLUS, you would handle this in the GPU/DSP WriteLong code! Not here!
 639         offset &= 0xFFFFFF;
 640
 641         if (offset <= 0x3FFFFE)
 642         {
 643 //This MUST be done by the 68K!
 644 /*if (offset == 0x670C)
 645         WriteLog("Jaguar: %s writing to location $670C...\n", whoName[who]);*/
 646
 647                 jaguar_mainRam[(offset+0) & 0x3FFFFF] = (data>>8) & 0xFF;
 648                 jaguar_mainRam[(offset+1) & 0x3FFFFF] = data & 0xFF;
 649                 return;
 650         }
 651         else if (offset >= 0xDFFF00 && offset <= 0xDFFFFE)
 652         {
 653                 CDROMWriteWord(offset, data, who);
 654                 return;
 655         }
 656         else if (offset >= 0xF00000 && offset <= 0xF0FFFE)
 657         {
 658                 TOMWriteWord(offset, data, who);
 659                 return;
 660         }
 661         else if (offset >= 0xF10000 && offset <= 0xF1FFFE)
 662         {
 663                 JERRYWriteWord(offset, data, who);
 664                 return;
 665         }
 666         // Don't bomb on attempts to write to ROM
 667         else if (offset >= 0x800000 && offset <= 0xEFFFFF)
 668                 return;
 669
 670         jaguar_unknown_writeword(offset, data, who);
 671 }
 672
 673 // We really should re-do this so that it does *real* 32-bit access... !!! FIX !!!
 674 uint32 JaguarReadLong(uint32 offset, uint32 who/*=UNKNOWN*/)
 675 {
 676         return (JaguarReadWord(offset, who) << 16) | JaguarReadWord(offset+2, who);
 677 }
 678
 679 // We really should re-do this so that it does *real* 32-bit access... !!! FIX !!!
 680 void JaguarWriteLong(uint32 offset, uint32 data, uint32 who/*=UNKNOWN*/)
 681 {
 682 /*      extern bool doDSPDis;
 683         if (offset < 0x400 && !doDSPDis)
 684         {
 685                 WriteLog("JLW: Write to %08X by %s... Starting DSP log!\n\n", offset, whoName[who]);
 686                 doDSPDis = true;
 687         }//*/
 688
 689         JaguarWriteWord(offset, data >> 16, who);
 690         JaguarWriteWord(offset+2, data & 0xFFFF, who);
 691 }
 692
 693 //
 694 // Jaguar console initialization
 695 //
 696 void jaguar_init(void)
 697 {
 698 #ifdef CPU_DEBUG_MEMORY
 699         memset(readMem, 0x00, 0x400000);
 700         memset(writeMemMin, 0xFF, 0x400000);
 701         memset(writeMemMax, 0x00, 0x400000);
 702 #endif
 703         memory_malloc_secure((void **)&jaguar_mainRam, 0x400000, "Jaguar 68K CPU RAM");
 704         memory_malloc_secure((void **)&jaguar_bootRom, 0x040000, "Jaguar 68K CPU BIOS ROM");
 705         memory_malloc_secure((void **)&jaguar_mainRom, 0x600000, "Jaguar 68K CPU ROM");
 706         memset(jaguar_mainRam, 0x00, 0x400000);
 707 //      memset(jaguar_mainRom, 0xFF, 0x200000); // & set it to all Fs...
 708 //      memset(jaguar_mainRom, 0x00, 0x200000); // & set it to all 0s...
 709 //NOTE: This *doesn't* fix FlipOut...
 710         memset(jaguar_mainRom, 0x01, 0x600000); // & set it to all 01s...
 711
 712 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\Brain Dead 13.cdi");
 713 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\baldies.cdi");
 714 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\mystdemo.cdi");
 715 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\battlemorph.cdi");
 716 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\primalrage.cdi");
 717 //      cd_bios_boot("C:\\ftp\\jaguar\\cd\\Dragons Lair.cdi");
 718
 719         m68k_set_cpu_type(M68K_CPU_TYPE_68000);
 720         gpu_init();
 721         DSPInit();
 722         tom_init();
 723         jerry_init();
 724         cdrom_init();
 725 }
 726
 727 void jaguar_done(void)
 728 {
 729 #ifdef CPU_DEBUG_MEMORY
 730 /*      WriteLog("\n\nM68000 disassembly at $8D0D44 (collision routine!)...\n");
 731         jaguar_dasm(0x8D0D44, 5000);
 732         WriteLog("\n");//*/
 733 /*      WriteLog("\n\nM68000 disassembly at $806300 (look @ $806410)...\n");
 734         jaguar_dasm(0x806300, 5000);
 735         WriteLog("\n");//*/
 736
 737 /*      WriteLog("\nJaguar: Memory Usage Stats (return addresses)\n\n");
 738
 739         for(uint32 i=0; i<=raPtr; i++)
 740         {
 741                 WriteLog("\t%08X\n", returnAddr[i]);
 742                 WriteLog("M68000 disassembly at $%08X...\n", returnAddr[i] - 16);
 743                 jaguar_dasm(returnAddr[i] - 16, 16);
 744                 WriteLog("\n");
 745         }
 746         WriteLog("\n");//*/
 747
 748 /*      int start = 0, end = 0;
 749         bool endTriggered = false, startTriggered = false;
 750         for(int i=0; i<0x400000; i++)
 751         {
 752                 if (readMem[i] && writeMemMin[i] != 0xFF && writeMemMax != 0x00)
 753                 {
 754                         if (!startTriggered)
 755                                 startTriggered = true, endTriggered = false, start = i;
 756
 757                         WriteLog("\t\tMin/Max @ %06X: %u/%u\n", i, writeMemMin[i], writeMemMax[i]);
 758                 }
 759                 else
 760                 {
 761                         if (!endTriggered)
 762                         {
 763                                 end = i - 1, endTriggered = true, startTriggered = false;
 764                                 WriteLog("\tMemory range accessed: %06X - %06X\n", start, end);
 765                         }
 766                 }
 767         }
 768         WriteLog("\n");//*/
 769 #endif
 770 //#ifdef CPU_DEBUG
 771 //      for(int i=M68K_REG_A0; i<=M68K_REG_A7; i++)
 772 //              WriteLog("\tA%i = 0x%.8x\n", i-M68K_REG_A0, m68k_get_reg(NULL, (m68k_register_t)i));
 773         int32 topOfStack = m68k_get_reg(NULL, M68K_REG_A7);
 774         WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack));
 775         for(int i=-2; i<9; i++)
 776                 WriteLog("%06X: %08X\n", topOfStack + (i * 4), JaguarReadLong(topOfStack + (i * 4)));
 777
 778 /*      WriteLog("\nM68000 disassembly at $802288...\n");
 779         jaguar_dasm(0x802288, 3);
 780         WriteLog("\nM68000 disassembly at $802200...\n");
 781         jaguar_dasm(0x802200, 500);
 782         WriteLog("\nM68000 disassembly at $802518...\n");
 783         jaguar_dasm(0x802518, 100);//*/
 784
 785 /*      WriteLog("\n\nM68000 disassembly at $803F00 (look @ $803F2A)...\n");
 786         jaguar_dasm(0x803F00, 500);
 787         WriteLog("\n");//*/
 788
 789 /*      WriteLog("\n\nM68000 disassembly at $802B00 (look @ $802B5E)...\n");
 790         jaguar_dasm(0x802B00, 500);
 791         WriteLog("\n");//*/
 792
 793 /*      WriteLog("\n\nM68000 disassembly at $809900 (look @ $8099F8)...\n");
 794         jaguar_dasm(0x809900, 500);
 795         WriteLog("\n");//*/
 796 //8099F8
 797 /*      WriteLog("\n\nDump of $8093C8:\n\n");
 798         for(int i=0x8093C8; i<0x809900; i+=4)
 799                 WriteLog("%06X: %08X\n", i, JaguarReadLong(i));//*/
 800 /*      WriteLog("\n\nM68000 disassembly at $90006C...\n");
 801         jaguar_dasm(0x90006C, 500);
 802         WriteLog("\n");//*/
 803
 804 //      WriteLog("Jaguar: CD BIOS version %04X\n", JaguarReadWord(0x3004));
 805         WriteLog("Jaguar: Interrupt enable = %02X\n", TOMReadByte(0xF000E1) & 0x1F);
 806         WriteLog("Jaguar: VBL interrupt is %s\n", ((tom_irq_enabled(IRQ_VBLANK)) && (jaguar_interrupt_handler_is_valid(64))) ? "enabled" : "disabled");
 807         M68K_show_context();
 808 //#endif
 809
 810         cd_bios_done();
 811         cdrom_done();
 812         gpu_done();
 813         DSPDone();
 814         tom_done();
 815         jerry_done();
 816
 817         memory_free(jaguar_mainRom);
 818         memory_free(jaguar_bootRom);
 819         memory_free(jaguar_mainRam);
 820 }
 821
 822 void jaguar_reset(void)
 823 {
 824         if (vjs.useJaguarBIOS)
 825                 memcpy(jaguar_mainRam, jaguar_bootRom, 8);
 826         else
 827         {
 828 // Should also make a run address global as well, for when we reset the jag (PD mainly)
 829 /*              SET32(jaguar_mainRam, 4, 0x00802000);
 830                 // Handle PD stuff...
 831                 // This should definitely go elsewhere (like in the cart load section)!
 832 //NOTE: The bytes 'JAGR' should also be at position $1C...
 833                 if (jaguar_mainRom[0] == 0x60 && jaguar_mainRom[1] == 0x1A)
 834                 {
 835                         uint32 loadAddress = GET32(jaguar_mainRom, 0x22), runAddress = GET32(jaguar_mainRom, 0x2A);
 836 //This is not always right! Especially when converted via bin2jag1!!!
 837 //We should have access to the length of the furshlumiger file that was loaded anyway!
 838 //Now, we do! ;-)
 839 //                      uint32 progLength = GET32(jaguar_mainRom, 0x02);
 840 //jaguarRomSize
 841 //jaguarRunAddress
 842 //                      WriteLog("Jaguar: Setting up PD ROM... Run address: %08X, length: %08X\n", runAddress, progLength);
 843 //                      memcpy(jaguar_mainRam + loadAddress, jaguar_mainRom + 0x2E, progLength);
 844                         WriteLog("Jaguar: Setting up PD ROM... Run address: %08X, length: %08X\n", runAddress, jaguarRomSize - 0x2E);
 845                         memcpy(jaguar_mainRam + loadAddress, jaguar_mainRom + 0x2E, jaguarRomSize - 0x2E);
 846                         SET32(jaguar_mainRam, 4, runAddress);
 847                 }//*/
 848                 SET32(jaguar_mainRam, 4, jaguarRunAddress);
 849         }
 850
 851 //      WriteLog("jaguar_reset():\n");
 852 //#ifdef SOUND_OUTPUT
 853 //      ws_audio_reset();
 854 //#endif
 855         cd_bios_reset();
 856         tom_reset();
 857         jerry_reset();
 858         gpu_reset();
 859         DSPReset();
 860         cdrom_reset();
 861     m68k_pulse_reset();                         // Reset the 68000
 862         WriteLog("\t68K PC=%06X SP=%08X\n", m68k_get_reg(NULL, M68K_REG_PC), m68k_get_reg(NULL, M68K_REG_A7));
 863 }
 864
 865 //
 866 // Main Jaguar execution loop (1 frame)
 867 //
 868 void JaguarExecute(int16 * backbuffer, bool render)
 869 {
 870         uint16 vp = TOMReadWord(0xF0003E) + 1;//Hmm. This is a WO register. Will work? Looks like. But wrong behavior!
 871         uint16 vi = TOMReadWord(0xF0004E);//Another WO register...
 872 //      uint16 vdb = TOMReadWord(0xF00046);
 873 //Note: This is the *definite* end of the display, though VDE *might* be less than this...
 874 //      uint16 vbb = TOMReadWord(0xF00040);
 875 //It seems that they mean it when they say that VDE is the end of object processing.
 876 //However, we need to be able to tell the OP (or TOM) that we've reached the end of the
 877 //buffer and not to write any more pixels... !!! FIX !!!
 878 //      uint16 vde = TOMReadWord(0xF00048);
 879
 880         uint16 refreshRate = (vjs.hardwareTypeNTSC ? 60 : 50);
 881         // Should these be hardwired or read from VP? Yes, from VP!
 882         uint32 M68KCyclesPerScanline
 883                 = (vjs.hardwareTypeNTSC ? M68K_CLOCK_RATE_NTSC : M68K_CLOCK_RATE_PAL) / (vp * refreshRate);
 884         uint32 RISCCyclesPerScanline
 885                 = (vjs.hardwareTypeNTSC ? RISC_CLOCK_RATE_NTSC : RISC_CLOCK_RATE_PAL) / (vp * refreshRate);
 886
 887         TOMResetBackbuffer(backbuffer);
 888 /*extern int effect_start;
 889 if (effect_start)
 890 {
 891         WriteLog("JagExe: VP=%u, VI=%u, VDB=%u, VBB=%u CPU CPS=%u, GPU CPS=%u\n", vp, vi, vdb, vbb, M68KCyclesPerScanline, RISCCyclesPerScanline);
 892 }//*/
 893
 894 //extern int start_logging;
 895         for(uint16 i=0; i<vp; i++)
 896         {
 897                 // Increment the horizontal count (why? RNG?)
 898                 TOMWriteWord(0xF00004, (TOMReadWord(0xF00004) + 1) & 0x7FF);
 899
 900                 TOMWriteWord(0xF00006, i);                                      // Write the VC
 901
 902                 if (i == vi)                                                            // Time for Vertical Interrupt?
 903                 {
 904                         if (tom_irq_enabled(IRQ_VBLANK))// && jaguar_interrupt_handler_is_valid(64))
 905                         {
 906                                 // We don't have to worry about autovectors & whatnot because the Jaguar
 907                                 // tells you through its HW registers who sent the interrupt...
 908                                 tom_set_pending_video_int();
 909                                 m68k_set_irq(7);
 910                         }
 911                 }
 912
 913 //              uint32 invalid_instruction_address = s68000exec(M68KCyclesPerScanline);
 914 //              if (invalid_instruction_address != 0x80000000)
 915 //                      cd_bios_process(invalid_instruction_address);
 916 //if (start_logging)
 917 //      WriteLog("About to execute M68K (%u)...\n", i);
 918                 m68k_execute(M68KCyclesPerScanline);
 919                 // No CD handling... !!! FIX !!!
 920 //if (start_logging)
 921 //      WriteLog("About to execute CD BIOS (%u)...\n", i);
 922                 cd_bios_exec(i);        // NOTE: Ignores parameter...
 923 //if (start_logging)
 924 //      WriteLog("About to execute TOM's PIT (%u)...\n", i);
 925                 TOMExecPIT(RISCCyclesPerScanline);
 926 //if (start_logging)
 927 //      WriteLog("About to execute JERRY's PIT (%u)...\n", i);
 928                 jerry_pit_exec(RISCCyclesPerScanline);
 929 //if (start_logging)
 930 //      WriteLog("About to execute JERRY's SSI (%u)...\n", i);
 931                 jerry_i2s_exec(RISCCyclesPerScanline);
 932 //if (start_logging)
 933 //      WriteLog("About to execute GPU (%u)...\n", i);
 934                 gpu_exec(RISCCyclesPerScanline);
 935
 936                 if (vjs.DSPEnabled)
 937                         if (vjs.usePipelinedDSP)
 938                                 DSPExecP2(RISCCyclesPerScanline);       // Pipelined DSP execution (3 stage)...
 939                         else
 940                                 DSPExec(RISCCyclesPerScanline);         // Ordinary non-pipelined DSP
 941 //                      DSPExecComp(RISCCyclesPerScanline);             // Comparison core
 942
 943 //if (start_logging)
 944 //      WriteLog("About to execute OP (%u)...\n", i);
 945                 TOMExecScanline(i, render);
 946         }
 947 }
 948
 949 // Temp debugging stuff
 950
 951 void DumpMainMemory(void)
 952 {
 953         FILE * fp = fopen("./memdump.bin", "wb");
 954
 955         if (fp == NULL)
 956                 return;
 957
 958         fwrite(jaguar_mainRam, 1, 0x400000, fp);
 959         fclose(fp);
 960 }
 961
 962 uint8 * GetRamPtr(void)
 963 {
 964         return jaguar_mainRam;
 965 }