home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser 2002 January / STC_CD_01_2002.iso / JAGUAR / JAG_SRC / SOURCE / MEM.C < prev    next >
C/C++ Source or Header  |  2001-08-17  |  44KB  |  1,314 lines
  1. ////////////////////////////////////////////////////////////////////////////////
  2. // Jagulator: Atari Jaguar Console Emulation Project (mem.c)
  3. // -----------------------------------------------------------------------------
  4. // Jagulator is the Copyright (c) RealityMan 1998-2001 and is provided "as is" 
  5. // without any expressed or implied warranty. I have no Trademarks, Legal or 
  6. // otherwise. Atari, Jaguar and the Atari Logo are copyright Hasbro Inc. All 
  7. // other Copyrights and Trademarks are acknowledged. This project is in no way 
  8. // linked to Atari/Hasbro or other associated Atari companies.                
  9. //
  10. // 07-07-2001 GH: New Source, Rewritten for Release 1.5.0
  11. // 00-00-0000 GH: All Previous Source Considered as Development Code Only
  12.  
  13. #include "core.h"
  14.  
  15. ////////////////////////////////////////////////////////////////////////////////
  16. // Globals
  17.  
  18.    extern char eeprom[];
  19.  
  20.    #ifdef DBGMEM
  21.    char memrdbg[] = "[0x%06X] %s --> 0x%04X\n";
  22.    char memwdbg[] = "[0x%06X] %s <-- 0x%04X\n";
  23.    #endif
  24.  
  25. ////////////////////////////////////////////////////////////////////////////////
  26. // TOM Read Word
  27.  
  28.    unsigned mem_tomreadw( unsigned addr )
  29.    {
  30.       dword ret;                       // Return Value
  31.  
  32.       ret = *(word *)(st.tom + (addr - 0xF00000));
  33.  
  34.       // GPU RAM Read
  35.       if( addr >= 0xF03000 && addr <= 0xF03FFF ) return( ret );
  36.  
  37.       // CLUT Read
  38.       if( addr >= 0xF00400 && addr <= 0xF007FE ) return( ret );
  39.  
  40.       switch( addr )  
  41.       {
  42.          case INT1:
  43.             #ifdef DBGMEM
  44.             print( memrdbg, INT1, "INT1     ", ret );
  45.             #endif
  46.             break;
  47.  
  48.          case G_CTRL: break;         
  49.          case 0xF02116:
  50.             ret &= 0x0FE9;             // Mask out Bits Not Changed on a Read
  51.             ret |= 0x2000;             // Include GPU Version
  52.             // Taken Out due to Repetition
  53.             // print( "[0xF02114] G_CTRL    --> 0x0000%04X\n", ret );
  54.             break;
  55.  
  56.          case B_CMD: break;
  57.          case 0xF0223A:
  58.             #ifdef DBGMEM
  59.             print( "[0xF02238] B_CMD     --> 0x0000%04X \n", blt.bltInactive );
  60.             #endif
  61.             return( blt.bltInactive );
  62.             break;
  63.  
  64.          case MEMCON1:
  65.             #ifdef DBGMEM
  66.             print( memrdbg, MEMCON1, "MEMCON1  ", ret );
  67.             #endif
  68.             break;
  69.  
  70.          case MEMCON2: 
  71.             #ifdef DBGMEM
  72.             print( memrdbg, MEMCON2, "MEMCON2  ", ret );
  73.             #endif
  74.             break;
  75.  
  76.          case LPH:
  77.             #ifdef DBGMEM
  78.             print( memrdbg, LPH, "LPH       ", ret );
  79.             #endif
  80.             break;
  81.  
  82.          case LPV:
  83.             #ifdef DBGMEM
  84.             print( memrdbg, LPV, "LPV       ", ret );
  85.             #endif
  86.             break;
  87.  
  88.          case OB0:
  89.             #ifdef DBGMEM
  90.             print( memrdbg, OB0, "OB0       ", ret );
  91.             #endif
  92.             break;
  93.  
  94.          case OB1:
  95.             #ifdef DBGMEM
  96.             print( memrdbg, OB1, "OB1       ", ret );
  97.             #endif
  98.             break;
  99.  
  100.          case OB2:
  101.             #ifdef DBGMEM
  102.             print( memrdbg, OB2, "OB2       ", ret );
  103.             #endif
  104.             break;
  105.  
  106.          case OB3:
  107.             #ifdef DBGMEM
  108.             print( memrdbg, OB3, "OB3       ", ret );
  109.             #endif
  110.             break;
  111.  
  112.          case VI:
  113.             #ifdef DBGMEM
  114.             print( memrdbg, VI, "VI       ", ret );
  115.             #endif
  116.             break;
  117.  
  118. //case G_FLAGS:
  119. //   write znc!!!
  120.  
  121.          default:
  122.             #ifdef DBGMEM
  123.             print( YEL"\'TOM\' Read Word at 0x%08X\n", addr );
  124.             #endif
  125.             return( 0 );
  126.             break;
  127.       }
  128.  
  129.       return( ret & 0x0000FFFF );
  130.    }
  131.  
  132. ////////////////////////////////////////////////////////////////////////////////
  133. // TOM Write Word
  134.  
  135.    void mem_tomwritew( unsigned addr, unsigned data )
  136.    {
  137.       data &= 0x0000FFFF;
  138.  
  139.       *(word *)(st.tom + (addr - 0xF00000)) = data;
  140.  
  141.       if( addr >= 0xF03000 && addr <= 0xF0FFFF ) return;
  142.  
  143.       if( addr >= 0xF00400 && addr <= 0xF007FE ) 
  144.       {
  145.          //color_ccry( addr, data );
  146.          switch( gst.cmode )
  147.          {
  148.             case 0: color_ccry( addr, data ); break;
  149.             case 3: color_crgb( addr, data ); break;
  150.          }
  151.          // Make Sure Write Happens to Both CLUTs
  152.          if( addr < 0xF00600 ) *(word *)(st.tom+((addr+0x200)-0xF00000))=data;
  153.          if( addr > 0xF005FF ) *(word *)(st.tom+((addr-0x200)-0xF00000))=data;
  154.          return;  
  155.       } 
  156.  
  157.       switch( addr )
  158.       {
  159.          case INT1:
  160.             #ifdef DBGMEM
  161.             print( memwdbg, INT1, "INT1      ", data );
  162.             if( data & C_VIDENA )
  163.                print( BROWN"%% Enable Video Interrupts\n" );
  164.             if( data & C_GPUENA )
  165.                print( BROWN"%% Enable GPU Interrupts\n" );
  166.             if( data & C_OPENA )
  167.                print( BROWN"%% Enable Object Processor Interrupts\n" );
  168.             if( data & C_PITENA )
  169.                print( BROWN"%% Enable PIT Interrupts\n" );
  170.             if( data & C_JERENA )
  171.                print( BROWN"%% Enable Jerry Interrupts\n" );
  172.             if( data & C_VIDCLR )
  173.                print( BROWN"%% Clear Video Interrupts\n" );
  174.             if( data & C_GPUCLR )
  175.                print( BROWN"%% Clear GPU Interrupts\n" );
  176.             if( data & C_OPCLR )
  177.                print( BROWN"%% Clear Object Processor Interrupts\n" );
  178.             if( data & C_PITCLR )
  179.                print( BROWN"%% Clear PIT Interrupts\n" );
  180.             if( data & C_JERCLR )
  181.                print( BROWN"%% Clear Jerry Interrupts\n" );
  182.             #endif
  183.             break;
  184.  
  185.          case G_FLAGS: break;
  186.          case 0xF02102:
  187.             #ifdef DBGMEM
  188.             print( "[0xF02100] G_FLAGS   <-- 0x%04X%04X\n",
  189.                     *(word *)(st.tom + 0x2100), *(word *)(st.tom + 0x2102) );
  190.  
  191.             if( data & G_CPUENA )    
  192.                print( BROWN"Enable GPU CPU Interrupt\n" );
  193.             if( data & G_DSPENA )    
  194.                print( BROWN"Enable GPU DSP Interrupt\n" );
  195.             if( data & G_PITENA )    
  196.                print( BROWN"Enable GPU Timer Interrupt\n" );
  197.             if( data & G_OPENA)    
  198.                print( BROWN"Enable GPU OP Interrupt\n" );
  199.             if( data & G_BLITENA )    
  200.                print( BROWN"Enable GPU Blitter Interrupt\n" );
  201.             if( data & G_CPUCLR )    
  202.                print( BROWN"Clear GPU CPU Interrupt\n" );
  203.             if( data & G_DSPCLR )    
  204.                print( BROWN"Clear GPU DSP Interrupt\n" );
  205.             if( data & G_PITCLR )    
  206.                print( BROWN"Clear GPU Timer Interrupt\n" );
  207.             if( data & G_OPCLR)    
  208.                print( BROWN"Clear GPU OP Interrupt\n" );
  209.             if( data & G_BLITCLR )    
  210.                print( BROWN"Clear GPU Blitter Interrupt\n" );
  211.             #endif
  212.  
  213.             if( data & REGPAGE )       // Switch Register Banks
  214.             {
  215.                sdword t;
  216.                int i;
  217.  
  218.                #ifdef DBGMEM
  219.                print( BROWN"GPU SWITCH REG BANKS\n");
  220.                #endif
  221.                
  222.                for( i = 0; i < 32; i ++ )
  223.                {
  224.                   t = gst.arb[i];
  225.                   gst.arb[i] = gst.srb[i];
  226.                   gst.srb[i] = t;
  227.                }
  228.             }
  229.  
  230.             #ifdef DBGMEM
  231.             if( data & DMAEN )         // DMAEN Enabled
  232.                print( BROWN"DMAEN Enable\n" );
  233.             #endif
  234.             break;
  235.  
  236.          case G_PC:
  237.             if( st.tom[0x2116] & (byte)GPUGO )
  238.             {
  239.                #ifdef DBGMEM
  240.                print( YEL"GPU ACTIVE - CANNOT UPDATE GPU PC\n" );
  241.                #endif
  242.             }
  243.             else
  244.                gpc = data << 16;
  245.             break;
  246.          case 0xF02112: gpc |= data; 
  247.             #ifdef DBGMEM
  248.             print( "[0xF02110] G_PC      <-- 0x%08X\n", gpc );
  249.             #endif
  250.             break;
  251.          
  252.          case G_CTRL: break;         
  253.          case 0xF02116: gst.ctrl = data;   
  254.             #ifdef DBGMEM
  255.             print( "[0xF02114] G_CTRL    <-- 0x%08X\n", gst.ctrl );
  256.             #endif
  257.             if( data & 0x0001 )        // GPU_GO
  258.             {
  259.                #ifdef DBGMEM
  260.                print( CYAN"GPU Starting\n" );
  261.                #endif
  262.                gst.gpuActive = TRUE;
  263.                gst.hGPUThread = CreateThread( NULL, 0, 
  264.                                               (LPTHREAD_START_ROUTINE)gpu_exec,
  265.                                               (LPVOID)0, 0, &gst.GPUTid );
  266.             }
  267.             else 
  268.             {
  269.                #ifdef DBGMEM
  270.                print( RED"GPU Stopping/Reset\n" );
  271.                #endif
  272.                gst.gpuActive = FALSE;
  273.             }
  274.             #ifdef DBGMEM
  275.             if( data & CPUINT ) 
  276.                print( BROWN"Allow GPU to Interrupt CPU\n" );
  277.             if( data & FORCEINT0 ) 
  278.                print( BROWN"Send GPU Interrupt Zero (TBC)\n" );
  279.             #endif
  280.             if( data & SINGLE_STEP )   
  281.             {
  282.                #ifdef DBGMEM
  283.                print( BROWN"GPU Single Stepping Enabled\n" );
  284.                #endif
  285.                gst.step = 1;
  286.             }
  287.             else
  288.             {
  289.                #ifdef DBGMEM
  290.                print( BROWN"GPU Single Stepping Disabled\n" );
  291.                #endif
  292.                gst.step = 0;
  293.             }
  294.             if( data & SINGLE_GO ) // SINGLE_GO
  295.             {
  296.                #ifdef DBGMEM
  297.                print( "Single Go: Advance GPU Execution by One Instruction\n" );
  298.                #endif
  299.                gst.stepgo = 1;
  300.             }
  301.             #ifdef DBGMEM
  302.             switch( data & 0xF000 )
  303.             {
  304.                case 0x2000:
  305.                   print( BROWN"Version: First Production Release\n" ); break;
  306.                case 0x1000:
  307.                   print( BROWN"Version: Pre-Production Test Silicon\n" ); break;
  308.                default:
  309.                   print( BROWN"Unknown GPU Version\n" ); break;
  310.             }
  311.             if( data & 0x0FE0 )
  312.                print( YEL"UNHANDLED G_CTRL DATA [0x%08X]\n", gst.ctrl );
  313.       
  314.             flushdisplay();
  315.             #endif
  316.             break;            
  317.  
  318.          case A1_BASE:  blt.a1base  = data << 16;     break;
  319.          case 0xF02202: blt.a1base |= data;           
  320.             #ifdef DBGMEM
  321.             print( "[0xF02200] A1_BASE   <-- 0x%08X\n", blt.a1base ); 
  322.             #endif
  323.             break;
  324.  
  325.          case A1_FLAGS: blt.a1flags  = data << 16;    break;
  326.          case 0xF02206: blt.a1flags |= data;
  327.             #ifdef DBGMEM
  328.             print( "[0xF02204] A1_FLAGS  <-- 0x%08X\n", blt.a1flags ); 
  329.             #endif
  330.             break;
  331.  
  332.          case A1_CLIP:  blt.a1clip  = data << 16;     break;
  333.          case 0xF0220A: blt.a1clip |= data; 
  334.             #ifdef DBGMEM
  335.             print( "[0xF02208] A1_CLIP   <-- 0x%08X\n", blt.a1clip ); 
  336.             #endif
  337.             break;
  338.  
  339.          case A1_PIXEL: blt.a1pixel  = data << 16;    break;
  340.          case 0xF0220E: blt.a1pixel |= data;         
  341.             #ifdef DBGMEM
  342.             print( "[0xF0220C] A1_PIXEL  <-- 0x%08X\n", blt.a1pixel ); 
  343.             #endif
  344.             break;
  345.  
  346.          case A1_STEP:  blt.a1step  = data << 16;     break;
  347.          case 0xF02212: blt.a1step |= data;      
  348.             #ifdef DBGMEM
  349.             print( "[0xF02210] A1_STEP   <-- 0x%08X\n", blt.a1step ); 
  350.             #endif
  351.             break;
  352.  
  353.          case A1_FSTEP: blt.a1fstep  = data << 16;    break;
  354.          case 0xF02216: blt.a1fstep |= data;        
  355.             #ifdef DBGMEM
  356.             print( "[0xF02214] A1_FSTEP  <-- 0x%08X\n", blt.a1fstep ); 
  357.             #endif
  358.             break;
  359.  
  360.          case A1_FPIXEL: blt.a1fpixel  = data << 16;  break;
  361.          case 0xF0221A:  blt.a1fpixel |= data;     
  362.             #ifdef DBGMEM
  363.             print( "[0xF02218] A1_FPIXEL <-- 0x%08X\n", blt.a1fpixel ); 
  364.             #endif
  365.             break;
  366.  
  367.          case A1_INC:   blt.a1inc  = data << 16;      break;
  368.          case 0xF0221E: blt.a1inc |= data;            
  369.             #ifdef DBGMEM
  370.             print( "[0xF0221C] A1_INC    <-- 0x%08X\n", blt.a1inc ); 
  371.             #endif
  372.             break;
  373.  
  374.          case A1_FINC:  blt.a1finc  = data << 16;     break;
  375.          case 0xF02222: blt.a1finc |= data;       
  376.             #ifdef DBGMEM
  377.             print( "[0xF02220] A1_FINC   <-- 0x%08X\n", blt.a1finc ); 
  378.             #endif
  379.             break;
  380.  
  381.          case A2_BASE:  blt.a2base  = data << 16;     break;
  382.          case 0xF02226: blt.a2base |= data;       
  383.             #ifdef DBGMEM
  384.             print( "[0xF02224] A2_BASE   <-- 0x%08X\n", blt.a2base ); 
  385.             #endif
  386.             break;
  387.  
  388.          case A2_FLAGS: blt.a2flags  = data << 16;    break;
  389.          case 0xF0222A: blt.a2flags |= data;      
  390.             #ifdef DBGMEM
  391.             print( "[0xF02228] A2_FLAGS  <-- 0x%08X\n", blt.a2flags ); 
  392.             #endif
  393.             break;
  394.  
  395.          case A2_MASK:  blt.a2mask  = data << 16;     break;
  396.          case 0xF0222E: blt.a2mask |= data;       
  397.             #ifdef DBGMEM
  398.             print( "[0xF0222C] A2_MASK   <-- 0x%08X\n", blt.a2mask ); 
  399.             #endif      
  400.             break;
  401.  
  402.          case A2_PIXEL: blt.a2pixel  = data << 16;    break;
  403.          case 0xF02232: blt.a2pixel |= data;      
  404.             #ifdef DBGMEM
  405.             print( "[0xF02230] A2_PIXEL  <-- 0x%08X\n", blt.a2pixel ); 
  406.             #endif
  407.             break;
  408.  
  409.          case A2_STEP:  blt.a2step  = data << 16;     break;
  410.          case 0xF02236: blt.a2step |= data;       
  411.             #ifdef DBGMEM
  412.             print( "[0xF02234] A2_STEP   <-- 0x%08X\n", blt.a2step ); 
  413.             #endif
  414.             break;
  415.  
  416.          case B_CMD:    blt.bcmd  = data << 16; break;
  417.          case 0xF0223A: blt.bcmd |= data;
  418.             #ifdef DBGMEM
  419.             print( "[0xF02238] B_CMD     <-- 0x%08X\n", blt.bcmd ); 
  420.             // Any Write Activates the Blitter
  421.             print( CYAN"Blitter Starting...\n" );
  422.             #endif
  423.             /*blt.hBLTThread = CreateThread( NULL, 0, 
  424.                                            (LPTHREAD_START_ROUTINE)exec_blitter,
  425.                                            (LPVOID)0, 0, &blt.BLTTid );*/
  426.             exec_blitter();
  427.             // This may well be able to be removed eventually
  428.             // Here for safety at the moment
  429.             //while( !blt.bltInactive ); // Wait for Blitter Operation to End
  430.  
  431.             #ifdef DBGMEM
  432.             print( RED"Blitter Stopped...\n" );
  433.             #endif
  434.             break;
  435.  
  436.          case B_COUNT:  blt.bcount  = data << 16;     break;
  437.          case 0xF0223E: blt.bcount |= data;       
  438.             #ifdef DBGMEM
  439.             print( "[0xF0223C] B_COUNT   <-- 0x%08X\n", blt.bcount ); 
  440.             #endif
  441.             break;
  442.  
  443.          case B_PATD:   blt.bpatd.hi  = data << 16; break;
  444.          case 0xF0226A: blt.bpatd.hi |= data;       break;
  445.          case 0xF0226C: blt.bpatd.lo  = data << 16; break;
  446.          case 0xF0226E: blt.bpatd.lo |= data;     
  447.             #ifdef DBGMEM
  448.             print( "[0xF02268] B_PATD    <-- 0x%08X%08X\n", 
  449.                     blt.bpatd.hi, blt.bpatd.lo ); 
  450.             #endif
  451.             break;
  452.  
  453.          case OLPLO: gst.olp  = data; break;
  454.          case OLPHI: gst.olp |= data << 16;
  455.             #ifdef DBGMEM
  456.             print( "[0xF00020] OLP       <-- 0x%08X\n", gst.olp );
  457.             #endif
  458.             break;
  459.  
  460.          case VMODE:
  461.             #ifdef DBGMEM
  462.             print( "[0xF00028] VMODE     <-- 0x%04X\n", data );
  463.             #endif
  464.             gst.vmode = data;
  465.  
  466.             if( !st.opened )
  467.             {
  468.                #ifdef DBGMEM
  469.                print( BROWN"Initialise Video\n" );
  470.                #endif
  471.                v_init( cfg.hres, cfg.vres );
  472.             }
  473.             switch( data & 0x0006 )
  474.             {
  475.                case 0x0000: 
  476.                   #ifdef DBGMEM
  477.                   print( BROWN"%% CRY16\n" ); 
  478.                   #endif
  479.                   gst.cmode = 0;       // CrY 16
  480.                   break;
  481.                case 0x0002: 
  482.                   #ifdef DBGMEM
  483.                   print( BROWN"%% RGB24\n" ); 
  484.                   #endif
  485.                   gst.cmode = 1;       // RGB 16
  486.                   break;
  487.                case 0x0004: 
  488.                   #ifdef DBGMEM
  489.                   print( BROWN"%% DIRECT16\n" ); 
  490.                   #endif
  491.                   gst.cmode = 2;       // Direct 16
  492.                   break;
  493.                case 0x0006: 
  494.                   #ifdef DBGMEM
  495.                   print( BROWN"%% RGB16\n" ); 
  496.                   #endif
  497.                   gst.cmode = 3;       // RGB 16
  498.                   break;
  499.             }
  500.             #ifdef DBGMEM
  501.             print( BROWN"%% PWIDTH = %i\n", (data & 0x0E00) >> 9 );
  502.             #endif
  503.             break;     
  504.  
  505.          case BORD1:    
  506.             #ifdef DBGMEM
  507.             print( memwdbg, BORD1, "BORD1     ", data );
  508.             #endif
  509.             break;
  510.  
  511.          case BORD2:    
  512.             #ifdef DBGMEM
  513.             print( memwdbg, BORD2, "BORD2     ", data );
  514.             #endif
  515.             break;
  516.  
  517.          case BG:
  518.             #ifdef DBGMEM
  519.             print( memwdbg, BG, "BG        ", data );
  520.             #endif      
  521.             {
  522.                dword tmp;
  523.  
  524.                tmp = cry16_rgb32( data, 0 );
  525.                st.br = (GLclampf)(tmp & 0x000000FF);
  526.                st.bg = (GLclampf)((tmp & 0x0000FF00) >> 8);
  527.                st.bb = (GLclampf)((tmp & 0x00FF0000) >> 16);
  528.             }
  529.             break;
  530.  
  531.          case MEMCON1:
  532.             #ifdef DBGMEM
  533.             print( memwdbg, MEMCON1, "MEMCON1   ", data );
  534.             #endif
  535.             break;
  536.  
  537.          case MEMCON2: 
  538.             #ifdef DBGMEM
  539.             print( memwdbg, MEMCON2, "MEMCON2   ", data );
  540.             #endif
  541.             break;
  542.  
  543.          case HC:
  544.             #ifdef DBGMEM
  545.             print( memwdbg, HC, "HC        ", data );
  546.             #endif
  547.             break;
  548.  
  549.          case VC:
  550.             #ifdef DBGMEM
  551.             print( memwdbg, VC, "VC        ", data );
  552.             #endif
  553.             break;
  554.  
  555.          case ODP: 
  556.             #ifdef DBGMEM
  557.              print( "[0xF00024] OP DtaPtr <-- 0x%02X%02X  "
  558.                     "(OP Internal Data Pointer/Flag - HI)\n", 
  559.                     st.tom[0x0025], st.tom[0x0024] );
  560.             #endif
  561.             break;
  562.  
  563.          case HP:
  564.             #ifdef DBGMEM
  565.             print( memwdbg, HP, "HP        ", data );
  566.             #endif
  567.             break;
  568.  
  569.          case HBB:
  570.             #ifdef DBGMEM
  571.             print( memwdbg, HBB, "HBB       ", data );
  572.             #endif
  573.             break;
  574.  
  575.          case HBE:
  576.             #ifdef DBGMEM
  577.             print( memwdbg, HBE, "HBE       ", data );
  578.             #endif
  579.             break;
  580.  
  581.          case HS:
  582.             #ifdef DBGMEM
  583.             print( memwdbg, HS, "HS        ", data );
  584.             #endif
  585.             break;
  586.  
  587.          case HVS:
  588.             #ifdef DBGMEM
  589.             print( memwdbg, HVS, "HVS       ", data );
  590.             #endif
  591.             break;
  592.  
  593.          case HDB1: 
  594.             #ifdef DBGMEM
  595.             print( memwdbg, HDB1, "HDB1      ", data );
  596.             #endif
  597.             break;
  598.  
  599.          case HDB2:
  600.             #ifdef DBGMEM
  601.             print( memwdbg, HDB2, "HDB2      ", data );
  602.             #endif
  603.             break;
  604.  
  605.          case HDE:
  606.             #ifdef DBGMEM
  607.             print( memwdbg, HDE, "HDE       ", data );
  608.             #endif
  609.             break;
  610.  
  611.          case VP:
  612.             #ifdef DBGMEM
  613.             print( memwdbg, VP, "VP        ", data );
  614.             #endif
  615.             break;
  616.  
  617.          case VBB:
  618.             #ifdef DBGMEM
  619.             print( memwdbg, VBB, "VBB       ", data );
  620.             #endif
  621.             break;
  622.  
  623.          case VBE:
  624.             #ifdef DBGMEM
  625.             print( memwdbg, VBE, "VBE       ", data );
  626.             #endif
  627.             break;
  628.  
  629.          case VS:
  630.             #ifdef DBGMEM
  631.             print( memwdbg, VS, "VS        ", data );
  632.             #endif
  633.             break;
  634.  
  635.          case VDB:
  636.             #ifdef DBGMEM
  637.             print( memwdbg, VDB, "VDB       ", data );
  638.             #endif
  639.             break;
  640.  
  641.          case VDE:
  642.             #ifdef DBGMEM
  643.             print( memwdbg, VDE, "VDE       ", data );
  644.             #endif
  645.             break;
  646.  
  647.          case VEB:
  648.             #ifdef DBGMEM
  649.             print( memwdbg, VEB, "VEB       ", data );
  650.             #endif
  651.             break;
  652.  
  653.          case VEE:
  654.             #ifdef DBGMEM
  655.             print( memwdbg, VEE, "VEE       ", data );
  656.             #endif
  657.             break;
  658.  
  659.          case VI:
  660.             #ifdef DBGMEM
  661.             print( memwdbg, VI, "VI        ", data );
  662.             #endif
  663.             break;
  664.  
  665.          case PIT0:
  666.             #ifdef DBGMEM
  667.             print( memwdbg, PIT0, "PIT0      ", data );
  668.             #endif
  669.             break;
  670.  
  671.          case PIT1:
  672.             #ifdef DBGMEM
  673.             print( memwdbg, PIT1, "PIT1      ", data );
  674.             #endif
  675.             break;
  676.  
  677.          case HEQ:
  678.             #ifdef DBGMEM
  679.             print( memwdbg, HEQ, "HEQ       ", data );
  680.             #endif
  681.             break;
  682.  
  683.          case INT2:
  684.             #ifdef DBGMEM
  685.             print( memwdbg, INT2, "INT2      ", data );            
  686.             #endif
  687.             break;
  688.  
  689.          case G_END: break;
  690.          case 0xF0210E: 
  691.             // This check can be removed once all data organisations are
  692.             // being handled.
  693.             #ifdef DBGMEM
  694.             if( st.tom[0x210C] != (byte)BIG_END || 
  695.                 st.tom[0x210E] != (byte)BIG_END )
  696.                error( "GPU DATA ORGANISATION CHANGED - "
  697.                       "Write to G_END [0x%04X%04X]",
  698.                       *(word *)(st.tom + 0x210C), *(word *)(st.tom + 0x210E) );
  699.             else
  700.                print( "[0xF0210C] G_END     <-- 0x%04X%04X\n", 
  701.                       *(word *)(st.tom + 0x210C), *(word *)(st.tom + 0x210E) );
  702.             break;
  703.             #endif
  704.  
  705.          default:
  706.             #ifdef DBGMEM
  707.             print( YEL"\'TOM\' Write Word at 0x%08X (Data = 0x%08X)\n", 
  708.                    addr, data );
  709.             #endif
  710.             break;
  711.       }   
  712.    }
  713.  
  714. ////////////////////////////////////////////////////////////////////////////////
  715. // JERRY Read Word
  716.  
  717.    unsigned mem_jryreadw( unsigned addr )
  718.    {
  719.       dword ret;                       // Return Value
  720.  
  721.       ret = *(word *)(st.jerry + (addr - 0xF10000));
  722.  
  723.       // DSP RAM Read + Waveforms
  724.       if( addr >= 0xF1B000 && addr < 0xF1E000 ) return( ret );
  725.  
  726.       switch( addr )  
  727.       {
  728.          case JOYSTICK:
  729.             #ifdef DBGMEM
  730.             //print( "[0xF14000] JOYSTICK  --> 0x%04X\n", ret );
  731.             #endif
  732.             break;
  733.  
  734.          case CONFIG:
  735.             #ifdef DBGMEM
  736.             //print( "[0xF14002] JOY/CFG   --> 0x%04X\n", ret );
  737.             #endif
  738.             break;
  739.            
  740.          case 0xF14800:
  741.             #ifdef DBGMEM
  742.             print( "[0xF14800] GPIO_0    --> 0x%04X\n", ret );
  743.             #endif
  744.             break;
  745.  
  746.          case 0xF15000:
  747.             #ifdef DBGMEM
  748.             print( "[0xF15000] GPIO_1    --> Strobe ChipSelect\n" );
  749.             #endif
  750.             break;
  751.  
  752. //case D_FLAGS:
  753. //   write znc!!!
  754.          default:
  755.             #ifdef DBGMEM
  756.             print( YEL"\'JERRY\' Read Word at 0x%08X\n", addr );
  757.             #endif
  758.             return( 0 );
  759.             break;
  760.       }
  761.  
  762.       return( ret & 0x0000FFFF );
  763.    }
  764.  
  765. ////////////////////////////////////////////////////////////////////////////////
  766. // JERRY Write Word
  767.  
  768.    void mem_jrywritew( unsigned addr, unsigned data )
  769.    {
  770.       word joyhi, joylo;
  771.  
  772.       data &= 0x0000FFFF;
  773.  
  774.       *(word *)(st.jerry + (addr - 0xF10000)) = data;
  775.  
  776.       // DSP RAM + Waveforms
  777.       if( addr >= 0xF1B000 && addr < 0xF1E000 ) return;
  778.  
  779.       switch( addr )
  780.       {
  781.          case JPIT1:
  782.             #ifdef DBGMEM
  783.             print( "[0xF10000] JPIT1     <-- 0x%04X\n", data );
  784.             #endif
  785.             break;
  786.  
  787.          case JPIT2:
  788.             #ifdef DBGMEM
  789.             print( "[0xF10002] JPIT2     <-- 0x%04X\n", data );
  790.             #endif
  791.             break;
  792.  
  793.          case CLK2:
  794.             #ifdef DBGMEM
  795.             print( "[0xF10012] CLK2      <-- 0x%04X\n", data );
  796.             #endif
  797.             break;
  798.  
  799.          case CHRO_CLK:
  800.             #ifdef DBGMEM
  801.             print( "[0xF10014] CHRO_CLK  <-- 0x%04X\n", data );
  802.             #endif
  803.             break;
  804.  
  805.          case J_INT:
  806.             #ifdef DBGMEM
  807.             print( "[0xF10020] J_INT     <-- 0x%04X\n", data );
  808.  
  809.             if( data & J_EXTENA  ) print( BROWN"%% Jerry - Enable External Interrupts\n" );
  810.             if( data & J_DSPENA  ) print( BROWN"%% Jerry - Enable DSP Interrupts\n" );
  811.             if( data & J_TIM1ENA ) print( BROWN"%% Jerry - Enable Timer1 Interrupts\n" );
  812.             if( data & J_TIM2ENA ) print( BROWN"%% Jerry - Enable Timer2 Interrupts\n" );
  813.             if( data & J_ASYNENA ) print( BROWN"%% Jerry - Enable Asynch Interrupts\n" );
  814.             if( data & J_SYNENA  ) print( BROWN"%% Jerry - Enable Synch Interrupts\n" );
  815.             if( data & J_EXTCLR  ) print( BROWN"%% Jerry - Clear Pending External Interrupts\n" );
  816.             if( data & J_DSPCLR  ) print( BROWN"%% Jerry - Clear Pending DSP Interrupts\n" );
  817.             if( data & J_TIM1CLR ) print( BROWN"%% Jerry - Clear Pending Timer1 Interrupts\n" );
  818.             if( data & J_TIM2CLR ) print( BROWN"%% Jerry - Clear Pending Timer2 Interrupts\n" );
  819.             if( data & J_ASYNCLR ) print( BROWN"%% Jerry - Clear Pending Asynch Interrupts\n" );
  820.             if( data & J_SYNCLR  ) print( BROWN"%% Jerry - Clear Pending Synch Interrupts\n" );
  821.             #endif
  822.             break;
  823.  
  824.          case JOYSTICK:
  825.             #ifdef DBGMEM
  826.             //print( "[0xF14000] JOYSTICK  <-- 0x%04X\n", data );
  827.             #endif
  828.  
  829. /*
  830. Port 1 MASK  = F0FF FFFC
  831.    
  832. Row0     Row1     Row2     Row3     Return
  833. ----     ----     ----     ----     ------
  834.   
  835. Pause    C1       C2       C3       0F00 0002
  836. A        B        C        Option   0F00 0001
  837. Up       *        0        #        0E00 0003
  838. Down     7        8        9        0D00 0003
  839. Left     4        5        6        0B00 0003
  840. Right    1        2        3        0700 0003
  841.  
  842. No Joy0 Pressed = 0F00 0003
  843.  
  844. Mappings:
  845.  
  846. A        A
  847. B        S
  848. C        X
  849. Up       Up
  850. Down     Down
  851. Left     Left
  852. Right    Right
  853. 0-9      0-9
  854. Option   O
  855. Pause    P
  856. *        K
  857. #        L
  858.  
  859. */
  860.                if( data & 0x8000 )
  861.             {
  862.                #ifdef DBGMEM
  863.                //print( "Enable JOYSTICK Outputs J7-J0\n" );
  864.                #endif
  865.                switch( data & 0x000F )
  866.                {
  867.                   case 0x000E:
  868.                      #ifdef DBGMEM
  869.                      //print(BROWN"%% Read Row 0 of Controller 0, Port 1\n" );
  870.                      #endif
  871.                      joyhi = 0xFFFF; joylo = 0xFFFF;
  872.                      if( GetAsyncKeyState( 0x50     ) & 0x8000 ) joylo &= 0xFFFE; // Button Pause
  873.                      if( GetAsyncKeyState( 0x41     ) & 0x8000 ) joylo &= 0xFFFD; // Button A
  874.                      if( GetAsyncKeyState( VK_UP    ) & 0x8000 ) joyhi &= 0xFEFF; // Button Up
  875.                      if( GetAsyncKeyState( VK_DOWN  ) & 0x8000 ) joyhi &= 0xFDFF; // Button Down
  876.                      if( GetAsyncKeyState( VK_LEFT  ) & 0x8000 ) joyhi &= 0xFBFF; // Button Left
  877.                      if( GetAsyncKeyState( VK_RIGHT ) & 0x8000 ) joyhi &= 0xF7FF; // Button Right
  878.                      *(word *)(st.jerry + 0x4000) = joyhi;
  879.                      *(word *)(st.jerry + 0x4002) = joylo;
  880.                      break;
  881.                   case 0x000D:
  882.                      #ifdef DBGMEM
  883.                      //print(BROWN"%% Read Row 1 of Controller 0, Port 1\n" );
  884.                      #endif
  885.                      joyhi = 0xFFFF; joylo = 0xFFFF;
  886.                      if( GetAsyncKeyState( 0x53 ) & 0x8000 ) joylo &= 0xFFFD; // Button B
  887.                      if( GetAsyncKeyState( 0x4B ) & 0x8000 ) joyhi &= 0xFEFF; // Button *
  888.                      if( GetAsyncKeyState( 0x37 ) & 0x8000 ) joyhi &= 0xFDFF; // Button 7
  889.                      if( GetAsyncKeyState( 0x34 ) & 0x8000 ) joyhi &= 0xFBFF; // Button 4
  890.                      if( GetAsyncKeyState( 0x31 ) & 0x8000 ) joyhi &= 0xF7FF; // Button 1
  891.                      *(word *)(st.jerry + 0x4000) = joyhi;
  892.                      *(word *)(st.jerry + 0x4002) = joylo;
  893.                      break;
  894.                   case 0x000B:
  895.                      #ifdef DBGMEM
  896.                      //print(BROWN"%% Read Row 2 of Controller 0, Port 1\n" );
  897.                      #endif
  898.                      joyhi = 0xFFFF; joylo = 0xFFFF;
  899.                      if( GetAsyncKeyState( 0x58 ) & 0x8000 ) joylo &= 0xFFFD; // Button C
  900.                      if( GetAsyncKeyState( 0x30 ) & 0x8000 ) joyhi &= 0xFEFF; // Button 0
  901.                      if( GetAsyncKeyState( 0x38 ) & 0x8000 ) joyhi &= 0xFDFF; // Button 8
  902.                      if( GetAsyncKeyState( 0x35 ) & 0x8000 ) joyhi &= 0xFBFF; // Button 5
  903.                      if( GetAsyncKeyState( 0x32 ) & 0x8000 ) joyhi &= 0xF7FF; // Button 2
  904.                      *(word *)(st.jerry + 0x4000) = joyhi;
  905.                      *(word *)(st.jerry + 0x4002) = joylo;
  906.                      break;
  907.                   case 0x0007:
  908.                      #ifdef DBGMEM
  909.                      //print(BROWN"%% Read Row 3 of Controller 0, Port 1\n" );
  910.                      #endif
  911.                      joyhi = 0xFFFF; joylo = 0xFFFF;
  912.                      if( GetAsyncKeyState( 0x4F ) & 0x8000 ) joylo &= 0xFFFD; // Button Option
  913.                      if( GetAsyncKeyState( 0x4C ) & 0x8000 ) joyhi &= 0xFEFF; // Button #
  914.                      if( GetAsyncKeyState( 0x39 ) & 0x8000 ) joyhi &= 0xFDFF; // Button 9
  915.                      if( GetAsyncKeyState( 0x36 ) & 0x8000 ) joyhi &= 0xFBFF; // Button 6
  916.                      if( GetAsyncKeyState( 0x33 ) & 0x8000 ) joyhi &= 0xF7FF; // Button 3
  917.                      *(word *)(st.jerry + 0x4000) = joyhi;
  918.                      *(word *)(st.jerry + 0x4002) = joylo;
  919.                      break;
  920.                   case 0x000F: break;
  921.                   default:
  922.                      #ifdef DBGMEM
  923.                      //print(BROWN"%% Unknown Row Read Identifier, Port 1\n" );
  924.                      #endif
  925.                      break;
  926.                }
  927.                switch( data & 0x00F0 )
  928.                {
  929.                   case 0x0007:
  930.                      *(word *)(st.jerry + 0x4000) = 0xFFFF;
  931.                      *(word *)(st.jerry + 0x4002) = 0xFFFF;
  932.                      #ifdef DBGMEM
  933.                      //print(BROWN"%% Read Row 0 of Controller 0, Port 2\n" );
  934.                      #endif
  935.                      break;
  936.                   case 0x000B:
  937.                      *(word *)(st.jerry + 0x4000) = 0xFFFF;
  938.                      *(word *)(st.jerry + 0x4002) = 0xFFFF;
  939.                      #ifdef DBGMEM
  940.                      //print(BROWN"%% Read Row 1 of Controller 0, Port 2\n" );
  941.                      #endif
  942.                      break;
  943.                   case 0x000D:
  944.                      *(word *)(st.jerry + 0x4000) = 0xFFFF;
  945.                      *(word *)(st.jerry + 0x4002) = 0xFFFF;
  946.                      #ifdef DBGMEM
  947.                      //print(BROWN"%% Read Row 2 of Controller 0, Port 2\n" );
  948.                      #endif
  949.                      break;
  950.                   case 0x000E:
  951.                      *(word *)(st.jerry + 0x4000) = 0xFFFF;
  952.                      *(word *)(st.jerry + 0x4002) = 0xFFFF;
  953.                      #ifdef DBGMEM
  954.                      //print(BROWN"%% Read Row 3 of Controller 0, Port 2\n" );
  955.                      #endif
  956.                      break;
  957.                   case 0x000F: break;
  958.                   default:
  959.                      #ifdef DBGMEM
  960.                      //print(BROWN"%% Unknown Row Read Identifier, Port 2\n" );
  961.                      #endif
  962.                      break;
  963.                }
  964.             }
  965.             else
  966.             {
  967.                #ifdef DBGMEM
  968.                    //print( "Disable JOYSTICK Outputs J7-J0\n" );
  969.                #endif
  970.             }
  971.  
  972.             if( data & 0x0100 ) 
  973.             {
  974.                cfg.sound = 1;
  975.                #ifdef DBGMEM
  976.                //print( BROWN"Audio Enabled\n" );
  977.                #endif
  978.             }
  979.             else
  980.             {
  981.                cfg.sound = 0;
  982.                #ifdef DBGMEM
  983.                //print( BROWN"Audio Muted\n" );
  984.                #endif
  985.             }
  986.             break;
  987.  
  988.          case 0xF14800:
  989.             if( (data & 0xFFC0) == 0x0180 )
  990.             {
  991.                #ifdef DBGMEM
  992.                print( "[0xF14800] GPIO_0    <-- Read From EEPROM (Word Index %02i)\n", (data & 0x003F) );
  993.                #endif
  994.                *(word *)(st.jerry + 0x4800) = *(word *)(eeprom + (data & 0x003F));
  995.             }
  996.             else
  997.             {
  998.                #ifdef DBGMEM
  999.                print( "[0xF14800] GPIO_0    <-- 0x%04X\n", data );
  1000.                #endif
  1001.             }
  1002.  
  1003.             break;
  1004.  
  1005.          case D_FLAGS: break;
  1006.          case 0xF1A102:
  1007.             #ifdef DBGMEM
  1008.                print( "[0xF1A100] D_FLAGS   <-- 0x%04X%04X\n", 
  1009.                       *(word *)(st.jerry + 0xA100), 
  1010.                       *(word *)(st.jerry + 0xA102) );
  1011.  
  1012.             if( data & D_CPUENA )    
  1013.                print( BROWN"Enable DSP CPU Interrupt\n" );
  1014.             if( data & D_I2SENA )    
  1015.                print( BROWN"Enable DSP I2S Interrupt\n" );
  1016.             if( data & D_TIM1ENA )    
  1017.                print( BROWN"Enable DSP Timer1 Interrupt\n" );
  1018.             if( data & D_TIM2ENA )    
  1019.                print( BROWN"Enable DSP Timer2 Interrupt\n" );
  1020.             if( data & D_EXT0ENA )    
  1021.                print( BROWN"Enable DSP EINT[0] Interrupt\n" );
  1022.             if( data & D_CPUCLR )    
  1023.                print( BROWN"Clear DSP CPU Interrupt\n" );
  1024.             if( data & D_I2SCLR )    
  1025.                print( BROWN"Clear DSP I2S Interrupt\n" );
  1026.             if( data & D_TIM1CLR)    
  1027.                print( BROWN"Clear DSP Timer1 Interrupt\n" );
  1028.             if( data & D_TIM2CLR )    
  1029.                print( BROWN"Clear DSP Timer2 Interrupt\n" );
  1030.             if( data & D_EXT0CLR )    
  1031.                print( BROWN"Clear DSP EINT[0] Interrupt\n" );
  1032.             #endif
  1033.  
  1034.             if( data & REGPAGE )       // Switch Register Banks
  1035.             {
  1036.                sdword t;
  1037.                int i;
  1038.  
  1039.                #ifdef DBGMEM
  1040.                print( BROWN"DSP Switch Register Banks\n");
  1041.                #endif
  1042.                
  1043.                for( i = 0; i < 32; i ++ )
  1044.                {
  1045.                   t = dst.arb[i];
  1046.                   dst.arb[i] = dst.srb[i];
  1047.                   dst.srb[i] = t;
  1048.  
  1049.                   //print( "ARB-R%02i = 0x%08X   SRB-R%02i = 0x%08X\n",
  1050.                   //        i, dst.arb[i], i, dst.srb[i] );
  1051.                }
  1052.  
  1053.                dst.bswitched = TRUE;
  1054.             }
  1055.             
  1056.             if( !(data & REGPAGE) && dst.bswitched )
  1057.             {
  1058.                sdword t;
  1059.                int i;
  1060.  
  1061.                #ifdef DBGMEM
  1062.                print( BROWN"DSP Restore Register Banks\n" );
  1063.                #endif
  1064.  
  1065.                for( i = 0; i < 32; i ++ )
  1066.                {
  1067.                   t = dst.arb[i];
  1068.                   dst.arb[i] = dst.srb[i];
  1069.                   dst.srb[i] = t;
  1070.  
  1071.                   //print( "ARB-R%02i = 0x%08X   SRB-R%02i = 0x%08X\n",
  1072.                   //        i, dst.arb[i], i, dst.srb[i] );
  1073.                }
  1074.  
  1075.                dst.bswitched = FALSE;
  1076.             }
  1077.  
  1078.             #ifdef DBGMEM
  1079.             if( data & DMAEN )    
  1080.                print( BROWN"DMA Enable\n" );
  1081.             if( data & D_EXT1ENA )    
  1082.                print( BROWN"Enable DSP EINT[1] Interrupt\n" );
  1083.             if( data & D_EXT1CLR )    
  1084.                print( BROWN"Enable DSP EINT[1] Interrupt\n" );
  1085.             #endif
  1086.  
  1087.             break;
  1088.  
  1089.          case D_END: break;
  1090.          case 0xF1A10E:
  1091.             // This check can be removed once all data organisations are
  1092.             // being handled.
  1093.             #ifdef DBGMEM
  1094.             if( st.jerry[0xA10C] != (byte)BIG_END || 
  1095.                 st.jerry[0xA10E] != (byte)BIG_END )
  1096.             {
  1097.                error( "DSP DATA ORGANISATION CHANGED - "
  1098.                       "Write to D_END [0x%04X%04X]", 
  1099.                       *(word *)(st.jerry + 0xA10C), 
  1100.                       *(word *)(st.jerry + 0xA10E) );
  1101.             }
  1102.             else
  1103.                print( "[0xF1A10C] D_END     <-- 0x%04X%04X\n", 
  1104.                       *(word *)(st.jerry + 0xA10C), 
  1105.                       *(word *)(st.jerry + 0xA10E) );
  1106.             #endif
  1107.             break;
  1108.  
  1109.          case D_PC:
  1110.             if( st.jerry[0xA116] & (byte)DSPGO )
  1111.             {
  1112.                #ifdef DBGMEM
  1113.                print( YEL"DSP ACTIVE - CANNOT UPDATE DSP PC\n" );
  1114.                #endif
  1115.             }
  1116.             else 
  1117.                dst.pc = data << 16;
  1118.             break;
  1119.          case 0xF1A112: dst.pc |= data; 
  1120.             #ifdef DBGMEM
  1121.             print( "[0xF1A110] D_PC      <-- 0x%08X\n", dst.pc );
  1122.             #endif
  1123.             break;
  1124.  
  1125.          case D_CTRL: break;
  1126.          case 0xF1A116:
  1127.             #ifdef DBGMEM
  1128.             print( "[0xF1A114] D_CTRL    <-- 0x%04X%04X\n",
  1129.                    *(word *)(st.jerry + 0xA114), 
  1130.                    *(word *)(st.jerry + 0xA116) );
  1131.             #endif
  1132.             if( data & DSPGO )
  1133.             {
  1134.                #ifdef DBGMEM
  1135.                print( CYAN"DSP Starting\n" );
  1136.                #endif
  1137.                dst.dspActive = TRUE;
  1138.                /*dst.hDSPThread = CreateThread( NULL, 0, 
  1139.                                             (LPTHREAD_START_ROUTINE)ExecDSP,
  1140.                                             (LPVOID)0, 0, &dst.DSPTid );*/
  1141.             }
  1142.             else
  1143.             {
  1144.                #ifdef DBGMEM
  1145.                print( RED"DSP Stopping/Reset\n" );
  1146.                #endif
  1147.                dst.dspActive = FALSE;
  1148.             }
  1149.             #ifdef DBGMEM
  1150.             if( data & 0xFFFE )
  1151.               print( YEL"UNHANDLED D_CTRL DATA\n" );
  1152.             #endif
  1153.             break;
  1154.  
  1155.          case D_MOD: break;
  1156.          case 0xF1A11A:
  1157.             #ifdef DBGMEM
  1158.             print( "[0xF1A118] D_MOD     <-- 0x%04X%04X\n", 
  1159.                    *(word *)(st.jerry + 0xA118), 
  1160.                    *(word *)(st.jerry + 0xA11A) );
  1161.             #endif
  1162.             break;
  1163.  
  1164.          case L_I2S: break;
  1165.          case 0xF1A14A:
  1166.             #ifdef DBGMEM
  1167.             print( "[0xF1A148] L_I2S     <-- 0x%04X%04X\n",
  1168.                    *(word *)(st.jerry + 0xA148), 
  1169.                    *(word *)(st.jerry + 0xA14A) );
  1170.             #endif
  1171.             break;
  1172.  
  1173.          case R_I2S: break;
  1174.          case 0xF1A14E:
  1175.             #ifdef DBGMEM
  1176.             print( "[0xF1A14C] R_I2S     <-- 0x%04X%04X\n",
  1177.                    *(word *)(st.jerry + 0xA14C), 
  1178.                    *(word *)(st.jerry + 0xA14E) );
  1179.             #endif
  1180.             break;
  1181.  
  1182.          case SCLK: break;
  1183.          case 0xF1A152:
  1184.             #ifdef DBGMEM
  1185.             print( "[0xF1A150] SCLK      <-- 0x%04X%04X\n",
  1186.                    *(word *)(st.jerry + 0xA150), 
  1187.                    *(word *)(st.jerry + 0xA152) );
  1188.             #endif
  1189.             break;
  1190.  
  1191.          case SMODE: break;
  1192.          case 0xF1A156:
  1193.             #ifdef DBGMEM
  1194.             print( "[0xF1A154] SMODE     <-- 0x%04X%04X\n",
  1195.                    *(word *)(st.jerry + 0xA154), 
  1196.                    *(word *)(st.jerry + 0xA156) );
  1197.             #endif
  1198.             break;
  1199.  
  1200.          default:
  1201.             #ifdef DBGMEM
  1202.             print( YEL"\'JERRY\' Write Word at 0x%08X (Data = 0x%08X)\n", 
  1203.                    addr, data );
  1204.             #endif
  1205.             break;
  1206.       }
  1207.    }
  1208.  
  1209. ////////////////////////////////////////////////////////////////////////////////
  1210. // Generic Read Word
  1211.  
  1212.    unsigned mem_readword( unsigned addr )
  1213.    {
  1214.       if( addr >= 0x000000 && addr <= 0x3FFFFF )
  1215.          return( *(word *)(st.ram + addr) );
  1216.  
  1217.       if( addr >= 0x800000 && addr <= 0xE00000 )
  1218.          return( *(word *)(st.game + (addr - 0x800000)) );
  1219.  
  1220.       if( addr >= 0xF00000 && addr <= 0xF0FFFF )
  1221.          return( mem_tomreadw( addr ) );
  1222.  
  1223.       if( addr >= 0xF10000 && addr <= 0xF1FFFF )
  1224.          return( mem_jryreadw( addr ) );
  1225.  
  1226.       #ifdef DBGMEM
  1227.       error( "Read Word at 0x%08X - Returning Zero\n", addr );
  1228.       #endif
  1229.       return( 0 );
  1230.    }
  1231.  
  1232. ////////////////////////////////////////////////////////////////////////////////
  1233. // Generic Read Byte
  1234.  
  1235.    unsigned mem_readbyte( unsigned addr )
  1236.    {
  1237.       // Main Ram Read Byte
  1238.       if( addr >= 0x000000 && addr <= 0x3FFFFF )
  1239.       {
  1240.          if( !(addr % 2) )             // Allow for Byte Swapping
  1241.             return( st.ram[addr + 1] );
  1242.          else
  1243.             return( st.ram[addr - 1] );
  1244.       }
  1245.  
  1246.       // Game Rom Read Byte
  1247.       if( addr >= 0x800000 && addr <= 0xDFFFFF )
  1248.       {
  1249.          if( !(addr % 2) )             // Allow for Byte Swapping
  1250.             return( st.game[(addr - 0x800000) + 1] );
  1251.          else
  1252.             return( st.game[(addr - 0x800000) - 1] );
  1253.       }
  1254.  
  1255.       #ifdef DBGMEM
  1256.       error( "Read Byte at 0x%08X, Returning Zero", addr );
  1257.       #endif
  1258.       return( 0 );
  1259.    }
  1260.  
  1261. ////////////////////////////////////////////////////////////////////////////////
  1262. // Generic Write Word
  1263.  
  1264.    void mem_writeword( unsigned addr, unsigned data )
  1265.    {
  1266.       if( addr >= 0x000000 && addr <= 0x3FFFFF )
  1267.       {
  1268.          *(word *)(st.ram + addr) = data;
  1269.          return;
  1270.       }
  1271.  
  1272.       if( addr >= 0xF03000 && addr <= 0xF04000 )
  1273.       {
  1274.          *(word *)(st.tom + (addr - 0xF00000)) = data;
  1275.          return;
  1276.       }
  1277.  
  1278.       if( addr >= 0xF00000 && addr <= 0xF0FFFF )
  1279.       {
  1280.          mem_tomwritew( addr, data );
  1281.          return;
  1282.       }
  1283.  
  1284.       if( addr >= 0xF10000 && addr <= 0xF1FFFF )  
  1285.       {
  1286.          mem_jrywritew( addr, data );
  1287.          return;
  1288.       }
  1289.       
  1290.       #ifdef DBGMEM
  1291.       error( "Write Word at 0x%08X (0x%08X)", addr, data );
  1292.       #endif
  1293.    }
  1294.  
  1295. ////////////////////////////////////////////////////////////////////////////////
  1296. // Generic Write Byte
  1297.  
  1298.    void mem_writebyte( unsigned addr, unsigned data )
  1299.    {
  1300.       // Main Ram Write Byte
  1301.       if( addr >= 0x000000 && addr <= 0x3FFFFF )   
  1302.       {
  1303.          if( !(addr % 2) )             // Allow for Byte Swapping
  1304.             st.ram[addr + 1] = (data & 0xFF);
  1305.          else
  1306.             st.ram[addr - 1] = (data & 0xFF);
  1307.          return;
  1308.       }
  1309.  
  1310.       #ifdef DBGMEM
  1311.       error( "Write Byte at 0x%08X (Data = 0x%08X)", addr, data );
  1312.       #endif
  1313.    }
  1314.