1 /***************************************************************************
2 * Copyright (C) 2010 by Blade_Arma *
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. *
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. *
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 ***************************************************************************/
21 * Internal PSX counters.
24 #include "psxcounters.h"
28 /******************************************************************************/
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)
56 #define CounterQuantity ( 4 )
57 //static const u32 CounterQuantity = 4;
59 static const u32 CountToOverflow = 0;
60 static const u32 CountToTarget = 1;
62 static const u32 FrameRate[] = { 60, 50 };
63 static const u32 HSyncTotal[] = { 263, 313 };
64 #define VBlankStart 240
66 #define VERBOSE_LEVEL 0
68 static const s32 VerboseLevel = VERBOSE_LEVEL;
71 /******************************************************************************/
73 Rcnt rcnts[ CounterQuantity ];
76 u32 frame_counter = 0;
77 static u32 hsync_steps = 0;
78 static u32 base_cycle = 0;
80 u32 psxNextCounter = 0, psxNextsCounter = 0;
82 /******************************************************************************/
85 void setIrq( u32 irq )
87 psxHu32ref(0x1070) |= SWAPu32(irq);
91 void verboseLog( u32 level, const char *str, ... )
94 if( level <= VerboseLevel )
100 vsprintf( buf, str, va );
109 /******************************************************************************/
112 void _psxRcntWcount( u32 index, u32 value )
116 verboseLog( 1, "[RCNT %i] wcount > 0xffff: %x\n", index, value );
120 rcnts[index].cycleStart = psxRegs.cycle;
121 rcnts[index].cycleStart -= value * rcnts[index].rate;
124 if( value < rcnts[index].target )
126 rcnts[index].cycle = rcnts[index].target * rcnts[index].rate;
127 rcnts[index].counterState = CountToTarget;
131 rcnts[index].cycle = 0x10000 * rcnts[index].rate;
132 rcnts[index].counterState = CountToOverflow;
137 u32 _psxRcntRcount( u32 index )
141 count = psxRegs.cycle;
142 count -= rcnts[index].cycleStart;
143 if (rcnts[index].rate > 1)
144 count /= rcnts[index].rate;
146 if( count > 0x10000 )
148 verboseLog( 1, "[RCNT %i] rcount > 0x10000: %x\n", index, count );
156 void _psxRcntWmode( u32 index, u32 value )
158 rcnts[index].mode = value;
163 if( value & Rc0PixelClock )
165 rcnts[index].rate = 5;
169 rcnts[index].rate = 1;
173 if( value & Rc1HSyncClock )
175 rcnts[index].rate = (PSXCLK / (FrameRate[Config.PsxType] * HSyncTotal[Config.PsxType]));
179 rcnts[index].rate = 1;
183 if( value & Rc2OneEighthClock )
185 rcnts[index].rate = 8;
189 rcnts[index].rate = 1;
192 // TODO: wcount must work.
193 if( value & Rc2Disable )
195 rcnts[index].rate = 0xffffffff;
201 /******************************************************************************/
209 psxNextsCounter = psxRegs.cycle;
210 psxNextCounter = 0x7fffffff;
212 for( i = 0; i < CounterQuantity; ++i )
214 countToUpdate = rcnts[i].cycle - (psxNextsCounter - rcnts[i].cycleStart);
216 if( countToUpdate < 0 )
222 if( countToUpdate < (s32)psxNextCounter )
224 psxNextCounter = countToUpdate;
228 psxRegs.interrupt |= (1 << PSXINT_RCNT);
229 new_dyna_set_event(PSXINT_RCNT, psxNextCounter);
232 /******************************************************************************/
235 void psxRcntReset( u32 index )
239 rcnts[index].mode |= RcUnknown10;
241 if( rcnts[index].counterState == CountToTarget )
243 rcycles = psxRegs.cycle - rcnts[index].cycleStart;
244 if( rcnts[index].mode & RcCountToTarget )
246 rcycles -= rcnts[index].target * rcnts[index].rate;
247 rcnts[index].cycleStart = psxRegs.cycle - rcycles;
251 rcnts[index].cycle = 0x10000 * rcnts[index].rate;
252 rcnts[index].counterState = CountToOverflow;
255 if( rcnts[index].mode & RcIrqOnTarget )
257 if( (rcnts[index].mode & RcIrqRegenerate) || (!rcnts[index].irqState) )
259 verboseLog( 3, "[RCNT %i] irq\n", index );
260 setIrq( rcnts[index].irq );
261 rcnts[index].irqState = 1;
265 rcnts[index].mode |= RcCountEqTarget;
267 if( rcycles < 0x10000 * rcnts[index].rate )
271 if( rcnts[index].counterState == CountToOverflow )
273 rcycles = psxRegs.cycle - rcnts[index].cycleStart;
274 rcycles -= 0x10000 * rcnts[index].rate;
276 rcnts[index].cycleStart = psxRegs.cycle - rcycles;
278 if( rcycles < rcnts[index].target * rcnts[index].rate )
280 rcnts[index].cycle = rcnts[index].target * rcnts[index].rate;
281 rcnts[index].counterState = CountToTarget;
284 if( rcnts[index].mode & RcIrqOnOverflow )
286 if( (rcnts[index].mode & RcIrqRegenerate) || (!rcnts[index].irqState) )
288 verboseLog( 3, "[RCNT %i] irq\n", index );
289 setIrq( rcnts[index].irq );
290 rcnts[index].irqState = 1;
294 rcnts[index].mode |= RcOverflow;
302 cycle = psxRegs.cycle;
305 if( cycle - rcnts[0].cycleStart >= rcnts[0].cycle )
311 if( cycle - rcnts[1].cycleStart >= rcnts[1].cycle )
317 if( cycle - rcnts[2].cycleStart >= rcnts[2].cycle )
323 if( cycle - rcnts[3].cycleStart >= rcnts[3].cycle )
325 u32 leftover_cycles = cycle - rcnts[3].cycleStart - rcnts[3].cycle;
328 hSyncCount += hsync_steps;
331 if( hSyncCount == VBlankStart )
333 HW_GPU_STATUS &= ~PSXGPU_LCF;
342 SPU_async( cycle, 1 );
346 // Update lace. (with InuYasha fix)
347 if( hSyncCount >= (Config.VSyncWA ? HSyncTotal[Config.PsxType] / BIAS : HSyncTotal[Config.PsxType]) )
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 );
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;
364 rcnts[3].cycleStart = cycle - leftover_cycles;
366 // 20.12 precision, clk / 50 / 313 ~= 2164.14
367 base_cycle += hsync_steps * 8864320;
369 // clk / 60 / 263 ~= 2146.31
370 base_cycle += hsync_steps * 8791293;
371 rcnts[3].cycle = base_cycle >> 12;
382 /******************************************************************************/
384 void psxRcntWcount( u32 index, u32 value )
386 verboseLog( 2, "[RCNT %i] wcount: %x\n", index, value );
388 _psxRcntWcount( index, value );
392 void psxRcntWmode( u32 index, u32 value )
394 verboseLog( 1, "[RCNT %i] wmode: %x\n", index, value );
396 _psxRcntWmode( index, value );
397 _psxRcntWcount( index, 0 );
399 rcnts[index].irqState = 0;
403 void psxRcntWtarget( u32 index, u32 value )
405 verboseLog( 1, "[RCNT %i] wtarget: %x\n", index, value );
407 rcnts[index].target = value;
409 _psxRcntWcount( index, _psxRcntRcount( index ) );
413 /******************************************************************************/
415 u32 psxRcntRcount( u32 index )
419 count = _psxRcntRcount( index );
421 // Parasite Eve 2 fix.
426 if( rcnts[index].counterState == CountToTarget )
433 verboseLog( 2, "[RCNT %i] rcount: %x\n", index, count );
438 u32 psxRcntRmode( u32 index )
442 mode = rcnts[index].mode;
443 rcnts[index].mode &= 0xe7ff;
445 verboseLog( 2, "[RCNT %i] rmode: %x\n", index, mode );
450 u32 psxRcntRtarget( u32 index )
452 verboseLog( 2, "[RCNT %i] rtarget: %x\n", index, rcnts[index].target );
454 return rcnts[index].target;
457 /******************************************************************************/
477 rcnts[3].mode = RcCountToTarget;
478 rcnts[3].target = (PSXCLK / (FrameRate[Config.PsxType] * HSyncTotal[Config.PsxType]));
480 for( i = 0; i < CounterQuantity; ++i )
482 _psxRcntWcount( i, 0 );
491 /******************************************************************************/
493 s32 psxRcntFreeze( void *f, s32 Mode )
495 u32 spuSyncCount = 0;
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) );
507 // don't trust things from a savestate
508 for( i = 0; i < CounterQuantity; ++i )
510 _psxRcntWmode( i, rcnts[i].mode );
511 count = (psxRegs.cycle - rcnts[i].cycleStart) / rcnts[i].rate;
512 _psxRcntWcount( i, count );
514 hsync_steps = (psxRegs.cycle - rcnts[3].cycleStart) / rcnts[3].target;
523 /******************************************************************************/