libpcsxcore/psxcounters.c

   1 /***************************************************************************
   2  *   Copyright (C) 2010 by Blade_Arma                                      *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
  18  ***************************************************************************/
  19
  20 /*
  21  * Internal PSX counters.
  22  */
  23
  24 #include "psxcounters.h"
  25 #include "gpu.h"
  26 #include "debug.h"
  27
  28 /******************************************************************************/
  29
  30 enum
  31 {
  32     Rc0Gate           = 0x0001, // 0    not implemented
  33     Rc1Gate           = 0x0001, // 0    not implemented
  34     Rc2Disable        = 0x0001, // 0    partially implemented
  35     RcUnknown1        = 0x0002, // 1    ?
  36     RcUnknown2        = 0x0004, // 2    ?
  37     RcCountToTarget   = 0x0008, // 3
  38     RcIrqOnTarget     = 0x0010, // 4
  39     RcIrqOnOverflow   = 0x0020, // 5
  40     RcIrqRegenerate   = 0x0040, // 6
  41     RcUnknown7        = 0x0080, // 7    ?
  42     Rc0PixelClock     = 0x0100, // 8    fake implementation
  43     Rc1HSyncClock     = 0x0100, // 8
  44     Rc2Unknown8       = 0x0100, // 8    ?
  45     Rc0Unknown9       = 0x0200, // 9    ?
  46     Rc1Unknown9       = 0x0200, // 9    ?
  47     Rc2OneEighthClock = 0x0200, // 9
  48     RcUnknown10       = 0x0400, // 10   ?
  49     RcCountEqTarget   = 0x0800, // 11
  50     RcOverflow        = 0x1000, // 12
  51     RcUnknown13       = 0x2000, // 13   ? (always zero)
  52     RcUnknown14       = 0x4000, // 14   ? (always zero)
  53     RcUnknown15       = 0x8000, // 15   ? (always zero)
  54 };
  55
  56 #define CounterQuantity           ( 4 )
  57 //static const u32 CounterQuantity  = 4;
  58
  59 static const u32 CountToOverflow  = 0;
  60 static const u32 CountToTarget    = 1;
  61
  62 static const u32 FrameRate[]      = { 60, 50 };
  63 static const u32 HSyncTotal[]     = { 263, 313 };
  64 #define VBlankStart 240
  65
  66 #define VERBOSE_LEVEL 0
  67 #if VERBOSE_LEVEL > 0
  68 static const s32 VerboseLevel     = VERBOSE_LEVEL;
  69 #endif
  70
  71 /******************************************************************************/
  72
  73 Rcnt rcnts[ CounterQuantity ];
  74
  75 u32 hSyncCount = 0;
  76 u32 frame_counter = 0;
  77 static u32 hsync_steps = 0;
  78 static u32 base_cycle = 0;
  79
  80 u32 psxNextCounter = 0, psxNextsCounter = 0;
  81
  82 /******************************************************************************/
  83
  84 static inline
  85 void setIrq( u32 irq )
  86 {
  87     psxHu32ref(0x1070) |= SWAPu32(irq);
  88 }
  89
  90 static
  91 void verboseLog( u32 level, const char *str, ... )
  92 {
  93 #if VERBOSE_LEVEL > 0
  94     if( level <= VerboseLevel )
  95     {
  96         va_list va;
  97         char buf[ 4096 ];
  98
  99         va_start( va, str );
 100         vsprintf( buf, str, va );
 101         va_end( va );
 102
 103         printf( "%s", buf );
 104         fflush( stdout );
 105     }
 106 #endif
 107 }
 108
 109 /******************************************************************************/
 110
 111 static inline
 112 void _psxRcntWcount( u32 index, u32 value )
 113 {
 114     if( value > 0xffff )
 115     {
 116         verboseLog( 1, "[RCNT %i] wcount > 0xffff: %x\n", index, value );
 117         value &= 0xffff;
 118     }
 119
 120     rcnts[index].cycleStart  = psxRegs.cycle;
 121     rcnts[index].cycleStart -= value * rcnts[index].rate;
 122
 123     // TODO: <=.
 124     if( value < rcnts[index].target )
 125     {
 126         rcnts[index].cycle = rcnts[index].target * rcnts[index].rate;
 127         rcnts[index].counterState = CountToTarget;
 128     }
 129     else
 130     {
 131         rcnts[index].cycle = 0x10000 * rcnts[index].rate;
 132         rcnts[index].counterState = CountToOverflow;
 133     }
 134 }
 135
 136 static inline
 137 u32 _psxRcntRcount( u32 index )
 138 {
 139     u32 count;
 140
 141     count  = psxRegs.cycle;
 142     count -= rcnts[index].cycleStart;
 143     if (rcnts[index].rate > 1)
 144         count /= rcnts[index].rate;
 145
 146     if( count > 0x10000 )
 147     {
 148         verboseLog( 1, "[RCNT %i] rcount > 0x10000: %x\n", index, count );
 149     }
 150     count &= 0xffff;
 151
 152     return count;
 153 }
 154
 155 static
 156 void _psxRcntWmode( u32 index, u32 value )
 157 {
 158     rcnts[index].mode = value;
 159
 160     switch( index )
 161     {
 162         case 0:
 163             if( value & Rc0PixelClock )
 164             {
 165                 rcnts[index].rate = 5;
 166             }
 167             else
 168             {
 169                 rcnts[index].rate = 1;
 170             }
 171         break;
 172         case 1:
 173             if( value & Rc1HSyncClock )
 174             {
 175                 rcnts[index].rate = (PSXCLK / (FrameRate[Config.PsxType] * HSyncTotal[Config.PsxType]));
 176             }
 177             else
 178             {
 179                 rcnts[index].rate = 1;
 180             }
 181         break;
 182         case 2:
 183             if( value & Rc2OneEighthClock )
 184             {
 185                 rcnts[index].rate = 8;
 186             }
 187             else
 188             {
 189                 rcnts[index].rate = 1;
 190             }
 191
 192             // TODO: wcount must work.
 193             if( value & Rc2Disable )
 194             {
 195                 rcnts[index].rate = 0xffffffff;
 196             }
 197         break;
 198     }
 199 }
 200
 201 /******************************************************************************/
 202
 203 static
 204 void psxRcntSet()
 205 {
 206     s32 countToUpdate;
 207     u32 i;
 208
 209     psxNextsCounter = psxRegs.cycle;
 210     psxNextCounter  = 0x7fffffff;
 211
 212     for( i = 0; i < CounterQuantity; ++i )
 213     {
 214         countToUpdate = rcnts[i].cycle - (psxNextsCounter - rcnts[i].cycleStart);
 215
 216         if( countToUpdate < 0 )
 217         {
 218             psxNextCounter = 0;
 219             break;
 220         }
 221
 222         if( countToUpdate < (s32)psxNextCounter )
 223         {
 224             psxNextCounter = countToUpdate;
 225         }
 226     }
 227
 228     psxRegs.interrupt |= (1 << PSXINT_RCNT);
 229     new_dyna_set_event(PSXINT_RCNT, psxNextCounter);
 230 }
 231
 232 /******************************************************************************/
 233
 234 static
 235 void psxRcntReset( u32 index )
 236 {
 237     u32 rcycles;
 238
 239     rcnts[index].mode |= RcUnknown10;
 240
 241     if( rcnts[index].counterState == CountToTarget )
 242     {
 243         rcycles = psxRegs.cycle - rcnts[index].cycleStart;
 244         if( rcnts[index].mode & RcCountToTarget )
 245         {
 246             rcycles -= rcnts[index].target * rcnts[index].rate;
 247             rcnts[index].cycleStart = psxRegs.cycle - rcycles;
 248         }
 249         else
 250         {
 251             rcnts[index].cycle = 0x10000 * rcnts[index].rate;
 252             rcnts[index].counterState = CountToOverflow;
 253         }
 254
 255         if( rcnts[index].mode & RcIrqOnTarget )
 256         {
 257             if( (rcnts[index].mode & RcIrqRegenerate) || (!rcnts[index].irqState) )
 258             {
 259                 verboseLog( 3, "[RCNT %i] irq\n", index );
 260                 setIrq( rcnts[index].irq );
 261                 rcnts[index].irqState = 1;
 262             }
 263         }
 264
 265         rcnts[index].mode |= RcCountEqTarget;
 266
 267         if( rcycles < 0x10000 * rcnts[index].rate )
 268             return;
 269     }
 270
 271     if( rcnts[index].counterState == CountToOverflow )
 272     {
 273         rcycles = psxRegs.cycle - rcnts[index].cycleStart;
 274         rcycles -= 0x10000 * rcnts[index].rate;
 275
 276         rcnts[index].cycleStart = psxRegs.cycle - rcycles;
 277
 278         if( rcycles < rcnts[index].target * rcnts[index].rate )
 279         {
 280             rcnts[index].cycle = rcnts[index].target * rcnts[index].rate;
 281             rcnts[index].counterState = CountToTarget;
 282         }
 283
 284         if( rcnts[index].mode & RcIrqOnOverflow )
 285         {
 286             if( (rcnts[index].mode & RcIrqRegenerate) || (!rcnts[index].irqState) )
 287             {
 288                 verboseLog( 3, "[RCNT %i] irq\n", index );
 289                 setIrq( rcnts[index].irq );
 290                 rcnts[index].irqState = 1;
 291             }
 292         }
 293
 294         rcnts[index].mode |= RcOverflow;
 295     }
 296 }
 297
 298 void psxRcntUpdate()
 299 {
 300     u32 cycle;
 301
 302     cycle = psxRegs.cycle;
 303
 304     // rcnt 0.
 305     if( cycle - rcnts[0].cycleStart >= rcnts[0].cycle )
 306     {
 307         psxRcntReset( 0 );
 308     }
 309
 310     // rcnt 1.
 311     if( cycle - rcnts[1].cycleStart >= rcnts[1].cycle )
 312     {
 313         psxRcntReset( 1 );
 314     }
 315
 316     // rcnt 2.
 317     if( cycle - rcnts[2].cycleStart >= rcnts[2].cycle )
 318     {
 319         psxRcntReset( 2 );
 320     }
 321
 322     // rcnt base.
 323     if( cycle - rcnts[3].cycleStart >= rcnts[3].cycle )
 324     {
 325         u32 leftover_cycles = cycle - rcnts[3].cycleStart - rcnts[3].cycle;
 326         u32 next_vsync;
 327
 328         hSyncCount += hsync_steps;
 329
 330         // VSync irq.
 331         if( hSyncCount == VBlankStart )
 332         {
 333             HW_GPU_STATUS &= ~PSXGPU_LCF;
 334             GPU_vBlank( 1, 0 );
 335             setIrq( 0x01 );
 336
 337             EmuUpdate();
 338             GPU_updateLace();
 339
 340             if( SPU_async )
 341             {
 342                 SPU_async( cycle, 1 );
 343             }
 344         }
 345
 346         // Update lace. (with InuYasha fix)
 347         if( hSyncCount >= (Config.VSyncWA ? HSyncTotal[Config.PsxType] / BIAS : HSyncTotal[Config.PsxType]) )
 348         {
 349             hSyncCount = 0;
 350             frame_counter++;
 351
 352             gpuSyncPluginSR();
 353             if( (HW_GPU_STATUS & PSXGPU_ILACE_BITS) == PSXGPU_ILACE_BITS )
 354                 HW_GPU_STATUS |= frame_counter << 31;
 355             GPU_vBlank( 0, HW_GPU_STATUS >> 31 );
 356         }
 357
 358         // Schedule next call, in hsyncs
 359         hsync_steps = HSyncTotal[Config.PsxType] - hSyncCount;
 360         next_vsync = VBlankStart - hSyncCount; // ok to overflow
 361         if( next_vsync && next_vsync < hsync_steps )
 362             hsync_steps = next_vsync;
 363
 364         rcnts[3].cycleStart = cycle - leftover_cycles;
 365         if (Config.PsxType)
 366                 // 20.12 precision, clk / 50 / 313 ~= 2164.14
 367                 base_cycle += hsync_steps * 8864320;
 368         else
 369                 // clk / 60 / 263 ~= 2146.31
 370                 base_cycle += hsync_steps * 8791293;
 371         rcnts[3].cycle = base_cycle >> 12;
 372         base_cycle &= 0xfff;
 373     }
 374
 375     psxRcntSet();
 376
 377 #ifndef NDEBUG
 378     DebugVSync();
 379 #endif
 380 }
 381
 382 /******************************************************************************/
 383
 384 void psxRcntWcount( u32 index, u32 value )
 385 {
 386     verboseLog( 2, "[RCNT %i] wcount: %x\n", index, value );
 387
 388     _psxRcntWcount( index, value );
 389     psxRcntSet();
 390 }
 391
 392 void psxRcntWmode( u32 index, u32 value )
 393 {
 394     verboseLog( 1, "[RCNT %i] wmode: %x\n", index, value );
 395
 396     _psxRcntWmode( index, value );
 397     _psxRcntWcount( index, 0 );
 398
 399     rcnts[index].irqState = 0;
 400     psxRcntSet();
 401 }
 402
 403 void psxRcntWtarget( u32 index, u32 value )
 404 {
 405     verboseLog( 1, "[RCNT %i] wtarget: %x\n", index, value );
 406
 407     rcnts[index].target = value;
 408
 409     _psxRcntWcount( index, _psxRcntRcount( index ) );
 410     psxRcntSet();
 411 }
 412
 413 /******************************************************************************/
 414
 415 u32 psxRcntRcount( u32 index )
 416 {
 417     u32 count;
 418
 419     count = _psxRcntRcount( index );
 420
 421     // Parasite Eve 2 fix.
 422     if( Config.RCntFix )
 423     {
 424         if( index == 2 )
 425         {
 426             if( rcnts[index].counterState == CountToTarget )
 427             {
 428                 count /= BIAS;
 429             }
 430         }
 431     }
 432
 433     verboseLog( 2, "[RCNT %i] rcount: %x\n", index, count );
 434
 435     return count;
 436 }
 437
 438 u32 psxRcntRmode( u32 index )
 439 {
 440     u16 mode;
 441
 442     mode = rcnts[index].mode;
 443     rcnts[index].mode &= 0xe7ff;
 444
 445     verboseLog( 2, "[RCNT %i] rmode: %x\n", index, mode );
 446
 447     return mode;
 448 }
 449
 450 u32 psxRcntRtarget( u32 index )
 451 {
 452     verboseLog( 2, "[RCNT %i] rtarget: %x\n", index, rcnts[index].target );
 453
 454     return rcnts[index].target;
 455 }
 456
 457 /******************************************************************************/
 458
 459 void psxRcntInit()
 460 {
 461     s32 i;
 462
 463     // rcnt 0.
 464     rcnts[0].rate   = 1;
 465     rcnts[0].irq    = 0x10;
 466
 467     // rcnt 1.
 468     rcnts[1].rate   = 1;
 469     rcnts[1].irq    = 0x20;
 470
 471     // rcnt 2.
 472     rcnts[2].rate   = 1;
 473     rcnts[2].irq    = 0x40;
 474
 475     // rcnt base.
 476     rcnts[3].rate   = 1;
 477     rcnts[3].mode   = RcCountToTarget;
 478     rcnts[3].target = (PSXCLK / (FrameRate[Config.PsxType] * HSyncTotal[Config.PsxType]));
 479
 480     for( i = 0; i < CounterQuantity; ++i )
 481     {
 482         _psxRcntWcount( i, 0 );
 483     }
 484
 485     hSyncCount = 0;
 486     hsync_steps = 1;
 487
 488     psxRcntSet();
 489 }
 490
 491 /******************************************************************************/
 492
 493 s32 psxRcntFreeze( void *f, s32 Mode )
 494 {
 495     u32 spuSyncCount = 0;
 496     u32 count;
 497     s32 i;
 498
 499     gzfreeze( &rcnts, sizeof(rcnts) );
 500     gzfreeze( &hSyncCount, sizeof(hSyncCount) );
 501     gzfreeze( &spuSyncCount, sizeof(spuSyncCount) );
 502     gzfreeze( &psxNextCounter, sizeof(psxNextCounter) );
 503     gzfreeze( &psxNextsCounter, sizeof(psxNextsCounter) );
 504
 505     if (Mode == 0)
 506     {
 507         // don't trust things from a savestate
 508         for( i = 0; i < CounterQuantity; ++i )
 509         {
 510             _psxRcntWmode( i, rcnts[i].mode );
 511             count = (psxRegs.cycle - rcnts[i].cycleStart) / rcnts[i].rate;
 512             _psxRcntWcount( i, count );
 513         }
 514         hsync_steps = (psxRegs.cycle - rcnts[3].cycleStart) / rcnts[3].target;
 515         psxRcntSet();
 516
 517         base_cycle = 0;
 518     }
 519
 520     return 0;
 521 }
 522
 523 /******************************************************************************/